@mastra/libsql 0.0.0-mcp-changeset-20250707162621 → 0.0.0-memory-system-message-error-20250813233316

package/dist/index.cjs

@@ -5,8 +5,9 @@ var error = require('@mastra/core/error');
 var utils = require('@mastra/core/utils');
 var vector = require('@mastra/core/vector');
 var filter = require('@mastra/core/vector/filter');
-var agent = require('@mastra/core/agent');
 var storage = require('@mastra/core/storage');
+var core = require('@mastra/core');
+var agent = require('@mastra/core/agent');
 
 // src/vector/index.ts
 var LibSQLFilterTranslator = class extends filter.BaseFilterTranslator {
@@ -77,11 +78,11 @@ var LibSQLFilterTranslator = class extends filter.BaseFilterTranslator {
 };
 var createBasicOperator = (symbol) => {
   return (key, value) => {
-    const jsonPathKey = parseJsonPathKey(key);
+    const jsonPath = getJsonPath(key);
     return {
       sql: `CASE 
-        WHEN ? IS NULL THEN json_extract(metadata, '$."${jsonPathKey}"') IS ${symbol === "=" ? "" : "NOT"} NULL
-        ELSE json_extract(metadata, '$."${jsonPathKey}"') ${symbol} ?
+        WHEN ? IS NULL THEN json_extract(metadata, ${jsonPath}) IS ${symbol === "=" ? "" : "NOT"} NULL
+        ELSE json_extract(metadata, ${jsonPath}) ${symbol} ?
       END`,
       needsValue: true,
       transformValue: () => {
@@ -92,16 +93,19 @@ var createBasicOperator = (symbol) => {
 };
 var createNumericOperator = (symbol) => {
   return (key) => {
-    const jsonPathKey = parseJsonPathKey(key);
+    const jsonPath = getJsonPath(key);
     return {
-      sql: `CAST(json_extract(metadata, '$."${jsonPathKey}"') AS NUMERIC) ${symbol} ?`,
+      sql: `CAST(json_extract(metadata, ${jsonPath}) AS NUMERIC) ${symbol} ?`,
       needsValue: true
     };
   };
 };
-var validateJsonArray = (key) => `json_valid(json_extract(metadata, '$."${key}"'))
-   AND json_type(json_extract(metadata, '$."${key}"')) = 'array'`;
-var pattern = /json_extract\(metadata, '\$\."[^"]*"(\."[^"]*")*'\)/g;
+var validateJsonArray = (key) => {
+  const jsonPath = getJsonPath(key);
+  return `json_valid(json_extract(metadata, ${jsonPath}))
+   AND json_type(json_extract(metadata, ${jsonPath})) = 'array'`;
+};
+var pattern = /json_extract\(metadata, '\$\.(?:"[^"]*"(?:\."[^"]*")*|[^']+)'\)/g;
 function buildElemMatchConditions(value) {
   const conditions = Object.entries(value).map(([field, fieldValue]) => {
     if (field.startsWith("$")) {
@@ -110,12 +114,13 @@ function buildElemMatchConditions(value) {
       return { sql: elemSql, values };
     } else if (typeof fieldValue === "object" && !Array.isArray(fieldValue)) {
       const { sql, values } = buildCondition(field, fieldValue);
-      const elemSql = sql.replace(pattern, `json_extract(elem.value, '$."${field}"')`);
+      const jsonPath = parseJsonPathKey(field);
+      const elemSql = sql.replace(pattern, `json_extract(elem.value, '$.${jsonPath}')`);
       return { sql: elemSql, values };
     } else {
-      const parsedFieldKey = utils.parseFieldKey(field);
+      const jsonPath = parseJsonPathKey(field);
       return {
-        sql: `json_extract(elem.value, '$."${parsedFieldKey}"') = ?`,
+        sql: `json_extract(elem.value, '$.${jsonPath}') = ?`,
         values: [fieldValue]
       };
     }
@@ -131,7 +136,7 @@ var FILTER_OPERATORS = {
   $lte: createNumericOperator("<="),
   // Array Operators
   $in: (key, value) => {
-    const jsonPathKey = parseJsonPathKey(key);
+    const jsonPath = getJsonPath(key);
     const arr = Array.isArray(value) ? value : [value];
     if (arr.length === 0) {
       return { sql: "1 = 0", needsValue: true, transformValue: () => [] };
@@ -140,12 +145,12 @@ var FILTER_OPERATORS = {
     return {
       sql: `(
       CASE
-        WHEN ${validateJsonArray(jsonPathKey)} THEN
+        WHEN ${validateJsonArray(key)} THEN
           EXISTS (
-            SELECT 1 FROM json_each(json_extract(metadata, '$."${jsonPathKey}"')) as elem
+            SELECT 1 FROM json_each(json_extract(metadata, ${jsonPath})) as elem
             WHERE elem.value IN (SELECT value FROM json_each(?))
           )
-        ELSE json_extract(metadata, '$."${jsonPathKey}"') IN (${paramPlaceholders})
+        ELSE json_extract(metadata, ${jsonPath}) IN (${paramPlaceholders})
       END
     )`,
       needsValue: true,
@@ -153,7 +158,7 @@ var FILTER_OPERATORS = {
     };
   },
   $nin: (key, value) => {
-    const jsonPathKey = parseJsonPathKey(key);
+    const jsonPath = getJsonPath(key);
     const arr = Array.isArray(value) ? value : [value];
     if (arr.length === 0) {
       return { sql: "1 = 1", needsValue: true, transformValue: () => [] };
@@ -162,12 +167,12 @@ var FILTER_OPERATORS = {
     return {
       sql: `(
       CASE
-        WHEN ${validateJsonArray(jsonPathKey)} THEN
+        WHEN ${validateJsonArray(key)} THEN
           NOT EXISTS (
-            SELECT 1 FROM json_each(json_extract(metadata, '$."${jsonPathKey}"')) as elem
+            SELECT 1 FROM json_each(json_extract(metadata, ${jsonPath})) as elem
             WHERE elem.value IN (SELECT value FROM json_each(?))
           )
-        ELSE json_extract(metadata, '$."${jsonPathKey}"') NOT IN (${paramPlaceholders})
+        ELSE json_extract(metadata, ${jsonPath}) NOT IN (${paramPlaceholders})
       END
     )`,
       needsValue: true,
@@ -175,7 +180,7 @@ var FILTER_OPERATORS = {
     };
   },
   $all: (key, value) => {
-    const jsonPathKey = parseJsonPathKey(key);
+    const jsonPath = getJsonPath(key);
     let sql;
     const arrayValue = Array.isArray(value) ? value : [value];
     if (arrayValue.length === 0) {
@@ -183,13 +188,13 @@ var FILTER_OPERATORS = {
     } else {
       sql = `(
       CASE
-        WHEN ${validateJsonArray(jsonPathKey)} THEN
+        WHEN ${validateJsonArray(key)} THEN
           NOT EXISTS (
             SELECT value
             FROM json_each(?)
             WHERE value NOT IN (
               SELECT value
-              FROM json_each(json_extract(metadata, '$."${jsonPathKey}"'))
+              FROM json_each(json_extract(metadata, ${jsonPath}))
             )
           )
         ELSE FALSE
@@ -208,7 +213,7 @@ var FILTER_OPERATORS = {
     };
   },
   $elemMatch: (key, value) => {
-    const jsonPathKey = parseJsonPathKey(key);
+    const jsonPath = getJsonPath(key);
     if (typeof value !== "object" || Array.isArray(value)) {
       throw new Error("$elemMatch requires an object with conditions");
     }
@@ -216,10 +221,10 @@ var FILTER_OPERATORS = {
     return {
       sql: `(
         CASE
-          WHEN ${validateJsonArray(jsonPathKey)} THEN
+          WHEN ${validateJsonArray(key)} THEN
             EXISTS (
               SELECT 1
-              FROM json_each(json_extract(metadata, '$."${jsonPathKey}"')) as elem
+              FROM json_each(json_extract(metadata, ${jsonPath})) as elem
               WHERE ${conditions.map((c) => c.sql).join(" AND ")}
             )
           ELSE FALSE
@@ -231,9 +236,9 @@ var FILTER_OPERATORS = {
   },
   // Element Operators
   $exists: (key) => {
-    const jsonPathKey = parseJsonPathKey(key);
+    const jsonPath = getJsonPath(key);
     return {
-      sql: `json_extract(metadata, '$."${jsonPathKey}"') IS NOT NULL`,
+      sql: `json_extract(metadata, ${jsonPath}) IS NOT NULL`,
       needsValue: false
     };
   },
@@ -252,12 +257,12 @@ var FILTER_OPERATORS = {
     needsValue: false
   }),
   $size: (key, paramIndex) => {
-    const jsonPathKey = parseJsonPathKey(key);
+    const jsonPath = getJsonPath(key);
     return {
       sql: `(
     CASE
-      WHEN json_type(json_extract(metadata, '$."${jsonPathKey}"')) = 'array' THEN 
-        json_array_length(json_extract(metadata, '$."${jsonPathKey}"')) = $${paramIndex}
+      WHEN json_type(json_extract(metadata, ${jsonPath})) = 'array' THEN 
+        json_array_length(json_extract(metadata, ${jsonPath})) = $${paramIndex}
       ELSE FALSE
     END
   )`,
@@ -376,7 +381,14 @@ function isFilterResult(obj) {
 }
 var parseJsonPathKey = (key) => {
   const parsedKey = utils.parseFieldKey(key);
-  return parsedKey.replace(/\./g, '"."');
+  if (parsedKey.includes(".")) {
+    return parsedKey.split(".").map((segment) => `"${segment}"`).join(".");
+  }
+  return parsedKey;
+};
+var getJsonPath = (key) => {
+  const jsonPathKey = parseJsonPathKey(key);
+  return `'$.${jsonPathKey}'`;
 };
 function escapeLikePattern(str) {
   return str.replace(/([%_\\])/g, "\\$1");
@@ -401,8 +413,9 @@ function buildCondition(key, value, parentPath) {
     return handleLogicalOperator(key, value);
   }
   if (!value || typeof value !== "object") {
+    const jsonPath = getJsonPath(key);
     return {
-      sql: `json_extract(metadata, '$."${key.replace(/\./g, '"."')}"') = ?`,
+      sql: `json_extract(metadata, ${jsonPath}) = ?`,
       values: [value]
     };
   }
@@ -548,7 +561,8 @@ var LibSQLVector = class extends vector.MastraVector {
     topK = 10,
     filter,
     includeVector = false,
-    minScore = 0
+    minScore = -1
+    // Default to -1 to include all results (cosine similarity ranges from -1 to 1)
   }) {
     try {
       if (!Number.isInteger(topK) || topK <= 0) {
@@ -651,7 +665,7 @@ var LibSQLVector = class extends vector.MastraVector {
       await tx.commit();
       return vectorIds;
     } catch (error) {
-      await tx.rollback();
+      !tx.closed && await tx.rollback();
       if (error instanceof Error && error.message?.includes("dimensions are different")) {
         const match = error.message.match(/dimensions are different: (\d+) != (\d+)/);
         if (match) {
@@ -906,270 +920,235 @@ var LibSQLVector = class extends vector.MastraVector {
     });
   }
 };
-function safelyParseJSON(jsonString) {
-  try {
-    return JSON.parse(jsonString);
-  } catch {
-    return {};
+function transformEvalRow(row) {
+  const resultValue = JSON.parse(row.result);
+  const testInfoValue = row.test_info ? JSON.parse(row.test_info) : void 0;
+  if (!resultValue || typeof resultValue !== "object" || !("score" in resultValue)) {
+    throw new Error(`Invalid MetricResult format: ${JSON.stringify(resultValue)}`);
   }
+  return {
+    input: row.input,
+    output: row.output,
+    result: resultValue,
+    agentName: row.agent_name,
+    metricName: row.metric_name,
+    instructions: row.instructions,
+    testInfo: testInfoValue,
+    globalRunId: row.global_run_id,
+    runId: row.run_id,
+    createdAt: row.created_at
+  };
 }
-var LibSQLStore = class extends storage.MastraStorage {
+var LegacyEvalsLibSQL = class extends storage.LegacyEvalsStorage {
   client;
-  maxRetries;
-  initialBackoffMs;
-  constructor(config) {
-    super({ name: `LibSQLStore` });
-    this.maxRetries = config.maxRetries ?? 5;
-    this.initialBackoffMs = config.initialBackoffMs ?? 100;
-    if (config.url.endsWith(":memory:")) {
-      this.shouldCacheInit = false;
-    }
-    this.client = client.createClient(config);
-    if (config.url.startsWith("file:") || config.url.includes(":memory:")) {
-      this.client.execute("PRAGMA journal_mode=WAL;").then(() => this.logger.debug("LibSQLStore: PRAGMA journal_mode=WAL set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA journal_mode=WAL.", err));
-      this.client.execute("PRAGMA busy_timeout = 5000;").then(() => this.logger.debug("LibSQLStore: PRAGMA busy_timeout=5000 set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA busy_timeout.", err));
-    }
-  }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true
-    };
-  }
-  getCreateTableSQL(tableName, schema) {
-    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
-    const columns = Object.entries(schema).map(([name, col]) => {
-      const parsedColumnName = utils.parseSqlIdentifier(name, "column name");
-      let type = col.type.toUpperCase();
-      if (type === "TEXT") type = "TEXT";
-      if (type === "TIMESTAMP") type = "TEXT";
-      const nullable = col.nullable ? "" : "NOT NULL";
-      const primaryKey = col.primaryKey ? "PRIMARY KEY" : "";
-      return `${parsedColumnName} ${type} ${nullable} ${primaryKey}`.trim();
-    });
-    if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
-      const stmnt = `CREATE TABLE IF NOT EXISTS ${parsedTableName} (
-                ${columns.join(",\n")},
-                PRIMARY KEY (workflow_name, run_id)
-            )`;
-      return stmnt;
-    }
-    return `CREATE TABLE IF NOT EXISTS ${parsedTableName} (${columns.join(", ")})`;
+  constructor({ client }) {
+    super();
+    this.client = client;
   }
-  async createTable({
-    tableName,
-    schema
-  }) {
+  /** @deprecated use getEvals instead */
+  async getEvalsByAgentName(agentName, type) {
     try {
-      this.logger.debug(`Creating database table`, { tableName, operation: "schema init" });
-      const sql = this.getCreateTableSQL(tableName, schema);
-      await this.client.execute(sql);
+      const baseQuery = `SELECT * FROM ${storage.TABLE_EVALS} WHERE agent_name = ?`;
+      const typeCondition = type === "test" ? " AND test_info IS NOT NULL AND test_info->>'testPath' IS NOT NULL" : type === "live" ? " AND (test_info IS NULL OR test_info->>'testPath' IS NULL)" : "";
+      const result = await this.client.execute({
+        sql: `${baseQuery}${typeCondition} ORDER BY created_at DESC`,
+        args: [agentName]
+      });
+      return result.rows?.map((row) => transformEvalRow(row)) ?? [];
     } catch (error$1) {
+      if (error$1 instanceof Error && error$1.message.includes("no such table")) {
+        return [];
+      }
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_CREATE_TABLE_FAILED",
+          id: "LIBSQL_STORE_GET_EVALS_BY_AGENT_NAME_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
+          details: { agentName }
         },
         error$1
       );
     }
   }
-  getSqlType(type) {
-    switch (type) {
-      case "bigint":
-        return "INTEGER";
-      // SQLite uses INTEGER for all integer sizes
-      case "jsonb":
-        return "TEXT";
-      // Store JSON as TEXT in SQLite
-      default:
-        return super.getSqlType(type);
+  async getEvals(options = {}) {
+    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const conditions = [];
+    const queryParams = [];
+    if (agentName) {
+      conditions.push(`agent_name = ?`);
+      queryParams.push(agentName);
     }
-  }
-  /**
-   * Alters table schema to add columns if they don't exist
-   * @param tableName Name of the table
-   * @param schema Schema of the table
-   * @param ifNotExists Array of column names to add if they don't exist
-   */
-  async alterTable({
-    tableName,
-    schema,
-    ifNotExists
-  }) {
-    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+    if (type === "test") {
+      conditions.push(`(test_info IS NOT NULL AND json_extract(test_info, '$.testPath') IS NOT NULL)`);
+    } else if (type === "live") {
+      conditions.push(`(test_info IS NULL OR json_extract(test_info, '$.testPath') IS NULL)`);
+    }
+    if (fromDate) {
+      conditions.push(`created_at >= ?`);
+      queryParams.push(fromDate.toISOString());
+    }
+    if (toDate) {
+      conditions.push(`created_at <= ?`);
+      queryParams.push(toDate.toISOString());
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
     try {
-      const pragmaQuery = `PRAGMA table_info(${parsedTableName})`;
-      const result = await this.client.execute(pragmaQuery);
-      const existingColumnNames = new Set(result.rows.map((row) => row.name.toLowerCase()));
-      for (const columnName of ifNotExists) {
-        if (!existingColumnNames.has(columnName.toLowerCase()) && schema[columnName]) {
-          const columnDef = schema[columnName];
-          const sqlType = this.getSqlType(columnDef.type);
-          const nullable = columnDef.nullable === false ? "NOT NULL" : "";
-          const defaultValue = columnDef.nullable === false ? this.getDefaultValue(columnDef.type) : "";
-          const alterSql = `ALTER TABLE ${parsedTableName} ADD COLUMN "${columnName}" ${sqlType} ${nullable} ${defaultValue}`.trim();
-          await this.client.execute(alterSql);
-          this.logger?.debug?.(`Added column ${columnName} to table ${parsedTableName}`);
-        }
+      const countResult = await this.client.execute({
+        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_EVALS} ${whereClause}`,
+        args: queryParams
+      });
+      const total = Number(countResult.rows?.[0]?.count ?? 0);
+      const currentOffset = page * perPage;
+      const hasMore = currentOffset + perPage < total;
+      if (total === 0) {
+        return {
+          evals: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
       }
+      const dataResult = await this.client.execute({
+        sql: `SELECT * FROM ${storage.TABLE_EVALS} ${whereClause} ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, perPage, currentOffset]
+      });
+      return {
+        evals: dataResult.rows?.map((row) => transformEvalRow(row)) ?? [],
+        total,
+        page,
+        perPage,
+        hasMore
+      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_ALTER_TABLE_FAILED",
+          id: "LIBSQL_STORE_GET_EVALS_FAILED",
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
-  async clearTable({ tableName }) {
-    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+};
+var MemoryLibSQL = class extends storage.MemoryStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  parseRow(row) {
+    let content = row.content;
     try {
-      await this.client.execute(`DELETE FROM ${parsedTableName}`);
-    } catch (e) {
-      const mastraError = new error.MastraError(
-        {
-          id: "LIBSQL_STORE_CLEAR_TABLE_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        e
-      );
-      this.logger?.trackException?.(mastraError);
-      this.logger?.error?.(mastraError.toString());
+      content = JSON.parse(row.content);
+    } catch {
     }
-  }
-  prepareStatement({ tableName, record }) {
-    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
-    const columns = Object.keys(record).map((col) => utils.parseSqlIdentifier(col, "column name"));
-    const values = Object.values(record).map((v) => {
-      if (typeof v === `undefined`) {
-        return null;
-      }
-      if (v instanceof Date) {
-        return v.toISOString();
-      }
-      return typeof v === "object" ? JSON.stringify(v) : v;
-    });
-    const placeholders = values.map(() => "?").join(", ");
-    return {
-      sql: `INSERT OR REPLACE INTO ${parsedTableName} (${columns.join(", ")}) VALUES (${placeholders})`,
-      args: values
+    const result = {
+      id: row.id,
+      content,
+      role: row.role,
+      createdAt: new Date(row.createdAt),
+      threadId: row.thread_id,
+      resourceId: row.resourceId
     };
+    if (row.type && row.type !== `v2`) result.type = row.type;
+    return result;
   }
-  async executeWriteOperationWithRetry(operationFn, operationDescription) {
-    let retries = 0;
-    while (true) {
-      try {
-        return await operationFn();
-      } catch (error) {
-        if (error.message && (error.message.includes("SQLITE_BUSY") || error.message.includes("database is locked")) && retries < this.maxRetries) {
-          retries++;
-          const backoffTime = this.initialBackoffMs * Math.pow(2, retries - 1);
-          this.logger.warn(
-            `LibSQLStore: Encountered SQLITE_BUSY during ${operationDescription}. Retrying (${retries}/${this.maxRetries}) in ${backoffTime}ms...`
-          );
-          await new Promise((resolve) => setTimeout(resolve, backoffTime));
-        } else {
-          this.logger.error(`LibSQLStore: Error during ${operationDescription} after ${retries} retries: ${error}`);
-          throw error;
-        }
-      }
+  async _getIncludedMessages({
+    threadId,
+    selectBy
+  }) {
+    const include = selectBy?.include;
+    if (!include) return null;
+    const unionQueries = [];
+    const params = [];
+    for (const inc of include) {
+      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+      const searchId = inc.threadId || threadId;
+      unionQueries.push(
+        `
+                SELECT * FROM (
+                  WITH numbered_messages AS (
+                    SELECT
+                      id, content, role, type, "createdAt", thread_id, "resourceId",
+                      ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
+                    FROM "${storage.TABLE_MESSAGES}"
+                    WHERE thread_id = ?
+                  ),
+                  target_positions AS (
+                    SELECT row_num as target_pos
+                    FROM numbered_messages
+                    WHERE id = ?
+                  )
+                  SELECT DISTINCT m.*
+                  FROM numbered_messages m
+                  CROSS JOIN target_positions t
+                  WHERE m.row_num BETWEEN (t.target_pos - ?) AND (t.target_pos + ?)
+                ) 
+                `
+        // Keep ASC for final sorting after fetching context
+      );
+      params.push(searchId, id, withPreviousMessages, withNextMessages);
     }
+    const finalQuery = unionQueries.join(" UNION ALL ") + ' ORDER BY "createdAt" ASC';
+    const includedResult = await this.client.execute({ sql: finalQuery, args: params });
+    const includedRows = includedResult.rows?.map((row) => this.parseRow(row));
+    const seen = /* @__PURE__ */ new Set();
+    const dedupedRows = includedRows.filter((row) => {
+      if (seen.has(row.id)) return false;
+      seen.add(row.id);
+      return true;
+    });
+    return dedupedRows;
   }
-  insert(args) {
-    return this.executeWriteOperationWithRetry(() => this.doInsert(args), `insert into table ${args.tableName}`);
-  }
-  async doInsert({
-    tableName,
-    record
+  async getMessages({
+    threadId,
+    selectBy,
+    format
   }) {
-    await this.client.execute(
-      this.prepareStatement({
-        tableName,
-        record
-      })
-    );
-  }
-  batchInsert(args) {
-    return this.executeWriteOperationWithRetry(
-      () => this.doBatchInsert(args),
-      `batch insert into table ${args.tableName}`
-    ).catch((error$1) => {
-      throw new error.MastraError(
-        {
-          id: "LIBSQL_STORE_BATCH_INSERT_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName: args.tableName
-          }
-        },
-        error$1
-      );
-    });
-  }
-  async doBatchInsert({
-    tableName,
-    records
-  }) {
-    if (records.length === 0) return;
-    const batchStatements = records.map((r) => this.prepareStatement({ tableName, record: r }));
-    await this.client.batch(batchStatements, "write");
-  }
-  async load({ tableName, keys }) {
-    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
-    const parsedKeys = Object.keys(keys).map((key) => utils.parseSqlIdentifier(key, "column name"));
-    const conditions = parsedKeys.map((key) => `${key} = ?`).join(" AND ");
-    const values = Object.values(keys);
-    const result = await this.client.execute({
-      sql: `SELECT * FROM ${parsedTableName} WHERE ${conditions} ORDER BY createdAt DESC LIMIT 1`,
-      args: values
-    });
-    if (!result.rows || result.rows.length === 0) {
-      return null;
-    }
-    const row = result.rows[0];
-    const parsed = Object.fromEntries(
-      Object.entries(row || {}).map(([k, v]) => {
-        try {
-          return [k, typeof v === "string" ? v.startsWith("{") || v.startsWith("[") ? JSON.parse(v) : v : v];
-        } catch {
-          return [k, v];
-        }
-      })
-    );
-    return parsed;
-  }
-  async getThreadById({ threadId }) {
     try {
-      const result = await this.load({
-        tableName: storage.TABLE_THREADS,
-        keys: { id: threadId }
-      });
-      if (!result) {
-        return null;
+      const messages = [];
+      const limit = storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
+      if (selectBy?.include?.length) {
+        const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
+        if (includeMessages) {
+          messages.push(...includeMessages);
+        }
       }
-      return {
-        ...result,
-        metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
-      };
+      const excludeIds = messages.map((m) => m.id);
+      const remainingSql = `
+        SELECT 
+          id, 
+          content, 
+          role, 
+          type,
+          "createdAt", 
+          thread_id,
+          "resourceId"
+        FROM "${storage.TABLE_MESSAGES}"
+        WHERE thread_id = ?
+        ${excludeIds.length ? `AND id NOT IN (${excludeIds.map(() => "?").join(", ")})` : ""}
+        ORDER BY "createdAt" DESC
+        LIMIT ?
+      `;
+      const remainingArgs = [threadId, ...excludeIds.length ? excludeIds : [], limit];
+      const remainingResult = await this.client.execute({ sql: remainingSql, args: remainingArgs });
+      if (remainingResult.rows) {
+        messages.push(...remainingResult.rows.map((row) => this.parseRow(row)));
+      }
+      messages.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+      const list = new agent.MessageList().add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_GET_THREAD_BY_ID_FAILED",
+          id: "LIBSQL_STORE_GET_MESSAGES_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { threadId }
@@ -1178,126 +1157,513 @@ var LibSQLStore = class extends storage.MastraStorage {
       );
     }
   }
-  /**
-   * @deprecated use getThreadsByResourceIdPaginated instead for paginated results.
-   */
-  async getThreadsByResourceId(args) {
-    const { resourceId } = args;
-    try {
-      const baseQuery = `FROM ${storage.TABLE_THREADS} WHERE resourceId = ?`;
-      const queryParams = [resourceId];
-      const mapRowToStorageThreadType = (row) => ({
-        id: row.id,
-        resourceId: row.resourceId,
-        title: row.title,
-        createdAt: new Date(row.createdAt),
-        // Convert string to Date
-        updatedAt: new Date(row.updatedAt),
-        // Convert string to Date
-        metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata
-      });
-      const result = await this.client.execute({
-        sql: `SELECT * ${baseQuery} ORDER BY createdAt DESC`,
-        args: queryParams
-      });
-      if (!result.rows) {
-        return [];
+  async getMessagesPaginated(args) {
+    const { threadId, format, selectBy } = args;
+    const { page = 0, perPage: perPageInput, dateRange } = selectBy?.pagination || {};
+    const perPage = perPageInput !== void 0 ? perPageInput : storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const messages = [];
+    if (selectBy?.include?.length) {
+      try {
+        const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
+        if (includeMessages) {
+          messages.push(...includeMessages);
+        }
+      } catch (error$1) {
+        throw new error.MastraError(
+          {
+            id: "LIBSQL_STORE_GET_MESSAGES_PAGINATED_GET_INCLUDE_MESSAGES_FAILED",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.THIRD_PARTY,
+            details: { threadId }
+          },
+          error$1
+        );
       }
-      return result.rows.map(mapRowToStorageThreadType);
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: "LIBSQL_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { resourceId }
-        },
-        error$1
-      );
-      this.logger?.trackException?.(mastraError);
-      this.logger?.error?.(mastraError.toString());
-      return [];
     }
-  }
-  async getThreadsByResourceIdPaginated(args) {
-    const { resourceId, page = 0, perPage = 100 } = args;
     try {
-      const baseQuery = `FROM ${storage.TABLE_THREADS} WHERE resourceId = ?`;
-      const queryParams = [resourceId];
-      const mapRowToStorageThreadType = (row) => ({
-        id: row.id,
-        resourceId: row.resourceId,
-        title: row.title,
-        createdAt: new Date(row.createdAt),
-        // Convert string to Date
-        updatedAt: new Date(row.updatedAt),
-        // Convert string to Date
-        metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata
-      });
       const currentOffset = page * perPage;
+      const conditions = [`thread_id = ?`];
+      const queryParams = [threadId];
+      if (fromDate) {
+        conditions.push(`"createdAt" >= ?`);
+        queryParams.push(fromDate.toISOString());
+      }
+      if (toDate) {
+        conditions.push(`"createdAt" <= ?`);
+        queryParams.push(toDate.toISOString());
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
       const countResult = await this.client.execute({
-        sql: `SELECT COUNT(*) as count ${baseQuery}`,
+        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_MESSAGES} ${whereClause}`,
         args: queryParams
       });
       const total = Number(countResult.rows?.[0]?.count ?? 0);
-      if (total === 0) {
+      if (total === 0 && messages.length === 0) {
         return {
-          threads: [],
+          messages: [],
           total: 0,
           page,
           perPage,
           hasMore: false
         };
       }
+      const excludeIds = messages.map((m) => m.id);
+      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + queryParams.length + 1}`).join(", ");
       const dataResult = await this.client.execute({
-        sql: `SELECT * ${baseQuery} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
-        args: [...queryParams, perPage, currentOffset]
+        sql: `SELECT id, content, role, type, "createdAt", "resourceId", "thread_id" FROM ${storage.TABLE_MESSAGES} ${whereClause} ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ""} ORDER BY "createdAt" DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, ...excludeIds, perPage, currentOffset]
       });
-      const threads = (dataResult.rows || []).map(mapRowToStorageThreadType);
+      messages.push(...(dataResult.rows || []).map((row) => this.parseRow(row)));
+      const messagesToReturn = format === "v1" ? new agent.MessageList().add(messages, "memory").get.all.v1() : new agent.MessageList().add(messages, "memory").get.all.v2();
       return {
-        threads,
+        messages: messagesToReturn,
         total,
         page,
         perPage,
-        hasMore: currentOffset + threads.length < total
+        hasMore: currentOffset + messages.length < total
       };
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "LIBSQL_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          id: "LIBSQL_STORE_GET_MESSAGES_PAGINATED_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { resourceId }
+          details: { threadId }
         },
         error$1
       );
       this.logger?.trackException?.(mastraError);
       this.logger?.error?.(mastraError.toString());
-      return { threads: [], total: 0, page, perPage, hasMore: false };
+      return { messages: [], total: 0, page, perPage, hasMore: false };
     }
   }
-  async saveThread({ thread }) {
+  async saveMessages({
+    messages,
+    format
+  }) {
+    if (messages.length === 0) return messages;
     try {
-      await this.insert({
-        tableName: storage.TABLE_THREADS,
-        record: {
-          ...thread,
-          metadata: JSON.stringify(thread.metadata)
+      const threadId = messages[0]?.threadId;
+      if (!threadId) {
+        throw new Error("Thread ID is required");
+      }
+      const batchStatements = messages.map((message) => {
+        const time = message.createdAt || /* @__PURE__ */ new Date();
+        if (!message.threadId) {
+          throw new Error(
+            `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`
+          );
+        }
+        if (!message.resourceId) {
+          throw new Error(
+            `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`
+          );
         }
+        return {
+          sql: `INSERT INTO "${storage.TABLE_MESSAGES}" (id, thread_id, content, role, type, "createdAt", "resourceId") 
+                  VALUES (?, ?, ?, ?, ?, ?, ?)
+                  ON CONFLICT(id) DO UPDATE SET
+                    thread_id=excluded.thread_id,
+                    content=excluded.content,
+                    role=excluded.role,
+                    type=excluded.type,
+                    "resourceId"=excluded."resourceId"
+                `,
+          args: [
+            message.id,
+            message.threadId,
+            typeof message.content === "object" ? JSON.stringify(message.content) : message.content,
+            message.role,
+            message.type || "v2",
+            time instanceof Date ? time.toISOString() : time,
+            message.resourceId
+          ]
+        };
       });
-      return thread;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      batchStatements.push({
+        sql: `UPDATE "${storage.TABLE_THREADS}" SET "updatedAt" = ? WHERE id = ?`,
+        args: [now, threadId]
+      });
+      const BATCH_SIZE = 50;
+      const messageStatements = batchStatements.slice(0, -1);
+      const threadUpdateStatement = batchStatements[batchStatements.length - 1];
+      for (let i = 0; i < messageStatements.length; i += BATCH_SIZE) {
+        const batch = messageStatements.slice(i, i + BATCH_SIZE);
+        if (batch.length > 0) {
+          await this.client.batch(batch, "write");
+        }
+      }
+      if (threadUpdateStatement) {
+        await this.client.execute(threadUpdateStatement);
+      }
+      const list = new agent.MessageList().add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_SAVE_THREAD_FAILED",
+          id: "LIBSQL_STORE_SAVE_MESSAGES_FAILED",
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId: thread.id }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
-      this.logger?.trackException?.(mastraError);
-      this.logger?.error?.(mastraError.toString());
+    }
+  }
+  async updateMessages({
+    messages
+  }) {
+    if (messages.length === 0) {
+      return [];
+    }
+    const messageIds = messages.map((m) => m.id);
+    const placeholders = messageIds.map(() => "?").join(",");
+    const selectSql = `SELECT * FROM ${storage.TABLE_MESSAGES} WHERE id IN (${placeholders})`;
+    const existingResult = await this.client.execute({ sql: selectSql, args: messageIds });
+    const existingMessages = existingResult.rows.map((row) => this.parseRow(row));
+    if (existingMessages.length === 0) {
+      return [];
+    }
+    const batchStatements = [];
+    const threadIdsToUpdate = /* @__PURE__ */ new Set();
+    const columnMapping = {
+      threadId: "thread_id"
+    };
+    for (const existingMessage of existingMessages) {
+      const updatePayload = messages.find((m) => m.id === existingMessage.id);
+      if (!updatePayload) continue;
+      const { id, ...fieldsToUpdate } = updatePayload;
+      if (Object.keys(fieldsToUpdate).length === 0) continue;
+      threadIdsToUpdate.add(existingMessage.threadId);
+      if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+        threadIdsToUpdate.add(updatePayload.threadId);
+      }
+      const setClauses = [];
+      const args = [];
+      const updatableFields = { ...fieldsToUpdate };
+      if (updatableFields.content) {
+        const newContent = {
+          ...existingMessage.content,
+          ...updatableFields.content,
+          // Deep merge metadata if it exists on both
+          ...existingMessage.content?.metadata && updatableFields.content.metadata ? {
+            metadata: {
+              ...existingMessage.content.metadata,
+              ...updatableFields.content.metadata
+            }
+          } : {}
+        };
+        setClauses.push(`${core.parseSqlIdentifier("content", "column name")} = ?`);
+        args.push(JSON.stringify(newContent));
+        delete updatableFields.content;
+      }
+      for (const key in updatableFields) {
+        if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+          const dbKey = columnMapping[key] || key;
+          setClauses.push(`${core.parseSqlIdentifier(dbKey, "column name")} = ?`);
+          let value = updatableFields[key];
+          if (typeof value === "object" && value !== null) {
+            value = JSON.stringify(value);
+          }
+          args.push(value);
+        }
+      }
+      if (setClauses.length === 0) continue;
+      args.push(id);
+      const sql = `UPDATE ${storage.TABLE_MESSAGES} SET ${setClauses.join(", ")} WHERE id = ?`;
+      batchStatements.push({ sql, args });
+    }
+    if (batchStatements.length === 0) {
+      return existingMessages;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const threadId of threadIdsToUpdate) {
+      if (threadId) {
+        batchStatements.push({
+          sql: `UPDATE ${storage.TABLE_THREADS} SET updatedAt = ? WHERE id = ?`,
+          args: [now, threadId]
+        });
+      }
+    }
+    await this.client.batch(batchStatements, "write");
+    const updatedResult = await this.client.execute({ sql: selectSql, args: messageIds });
+    return updatedResult.rows.map((row) => this.parseRow(row));
+  }
+  async deleteMessages(messageIds) {
+    if (!messageIds || messageIds.length === 0) {
+      return;
+    }
+    try {
+      const BATCH_SIZE = 100;
+      const threadIds = /* @__PURE__ */ new Set();
+      const tx = await this.client.transaction("write");
+      try {
+        for (let i = 0; i < messageIds.length; i += BATCH_SIZE) {
+          const batch = messageIds.slice(i, i + BATCH_SIZE);
+          const placeholders = batch.map(() => "?").join(",");
+          const result = await tx.execute({
+            sql: `SELECT DISTINCT thread_id FROM "${storage.TABLE_MESSAGES}" WHERE id IN (${placeholders})`,
+            args: batch
+          });
+          result.rows?.forEach((row) => {
+            if (row.thread_id) threadIds.add(row.thread_id);
+          });
+          await tx.execute({
+            sql: `DELETE FROM "${storage.TABLE_MESSAGES}" WHERE id IN (${placeholders})`,
+            args: batch
+          });
+        }
+        if (threadIds.size > 0) {
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          for (const threadId of threadIds) {
+            await tx.execute({
+              sql: `UPDATE "${storage.TABLE_THREADS}" SET "updatedAt" = ? WHERE id = ?`,
+              args: [now, threadId]
+            });
+          }
+        }
+        await tx.commit();
+      } catch (error) {
+        await tx.rollback();
+        throw error;
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LIBSQL_STORE_DELETE_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { messageIds: messageIds.join(", ") }
+        },
+        error$1
+      );
+    }
+  }
+  async getResourceById({ resourceId }) {
+    const result = await this.operations.load({
+      tableName: storage.TABLE_RESOURCES,
+      keys: { id: resourceId }
+    });
+    if (!result) {
+      return null;
+    }
+    return {
+      ...result,
+      // Ensure workingMemory is always returned as a string, even if auto-parsed as JSON
+      workingMemory: result.workingMemory && typeof result.workingMemory === "object" ? JSON.stringify(result.workingMemory) : result.workingMemory,
+      metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata,
+      createdAt: new Date(result.createdAt),
+      updatedAt: new Date(result.updatedAt)
+    };
+  }
+  async saveResource({ resource }) {
+    await this.operations.insert({
+      tableName: storage.TABLE_RESOURCES,
+      record: {
+        ...resource,
+        metadata: JSON.stringify(resource.metadata)
+      }
+    });
+    return resource;
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    const existingResource = await this.getResourceById({ resourceId });
+    if (!existingResource) {
+      const newResource = {
+        id: resourceId,
+        workingMemory,
+        metadata: metadata || {},
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      return this.saveResource({ resource: newResource });
+    }
+    const updatedResource = {
+      ...existingResource,
+      workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+      metadata: {
+        ...existingResource.metadata,
+        ...metadata
+      },
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const updates = [];
+    const values = [];
+    if (workingMemory !== void 0) {
+      updates.push("workingMemory = ?");
+      values.push(workingMemory);
+    }
+    if (metadata) {
+      updates.push("metadata = ?");
+      values.push(JSON.stringify(updatedResource.metadata));
+    }
+    updates.push("updatedAt = ?");
+    values.push(updatedResource.updatedAt.toISOString());
+    values.push(resourceId);
+    await this.client.execute({
+      sql: `UPDATE ${storage.TABLE_RESOURCES} SET ${updates.join(", ")} WHERE id = ?`,
+      args: values
+    });
+    return updatedResource;
+  }
+  async getThreadById({ threadId }) {
+    try {
+      const result = await this.operations.load({
+        tableName: storage.TABLE_THREADS,
+        keys: { id: threadId }
+      });
+      if (!result) {
+        return null;
+      }
+      return {
+        ...result,
+        metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata,
+        createdAt: new Date(result.createdAt),
+        updatedAt: new Date(result.updatedAt)
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LIBSQL_STORE_GET_THREAD_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead for paginated results.
+   */
+  async getThreadsByResourceId(args) {
+    const resourceId = args.resourceId;
+    const orderBy = this.castThreadOrderBy(args.orderBy);
+    const sortDirection = this.castThreadSortDirection(args.sortDirection);
+    try {
+      const baseQuery = `FROM ${storage.TABLE_THREADS} WHERE resourceId = ?`;
+      const queryParams = [resourceId];
+      const mapRowToStorageThreadType = (row) => ({
+        id: row.id,
+        resourceId: row.resourceId,
+        title: row.title,
+        createdAt: new Date(row.createdAt),
+        // Convert string to Date
+        updatedAt: new Date(row.updatedAt),
+        // Convert string to Date
+        metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata
+      });
+      const result = await this.client.execute({
+        sql: `SELECT * ${baseQuery} ORDER BY ${orderBy} ${sortDirection}`,
+        args: queryParams
+      });
+      if (!result.rows) {
+        return [];
+      }
+      return result.rows.map(mapRowToStorageThreadType);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "LIBSQL_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error$1
+      );
+      this.logger?.trackException?.(mastraError);
+      this.logger?.error?.(mastraError.toString());
+      return [];
+    }
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    const { resourceId, page = 0, perPage = 100 } = args;
+    const orderBy = this.castThreadOrderBy(args.orderBy);
+    const sortDirection = this.castThreadSortDirection(args.sortDirection);
+    try {
+      const baseQuery = `FROM ${storage.TABLE_THREADS} WHERE resourceId = ?`;
+      const queryParams = [resourceId];
+      const mapRowToStorageThreadType = (row) => ({
+        id: row.id,
+        resourceId: row.resourceId,
+        title: row.title,
+        createdAt: new Date(row.createdAt),
+        // Convert string to Date
+        updatedAt: new Date(row.updatedAt),
+        // Convert string to Date
+        metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata
+      });
+      const currentOffset = page * perPage;
+      const countResult = await this.client.execute({
+        sql: `SELECT COUNT(*) as count ${baseQuery}`,
+        args: queryParams
+      });
+      const total = Number(countResult.rows?.[0]?.count ?? 0);
+      if (total === 0) {
+        return {
+          threads: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const dataResult = await this.client.execute({
+        sql: `SELECT * ${baseQuery} ORDER BY ${orderBy} ${sortDirection} LIMIT ? OFFSET ?`,
+        args: [...queryParams, perPage, currentOffset]
+      });
+      const threads = (dataResult.rows || []).map(mapRowToStorageThreadType);
+      return {
+        threads,
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + threads.length < total
+      };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "LIBSQL_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error$1
+      );
+      this.logger?.trackException?.(mastraError);
+      this.logger?.error?.(mastraError.toString());
+      return { threads: [], total: 0, page, perPage, hasMore: false };
+    }
+  }
+  async saveThread({ thread }) {
+    try {
+      await this.operations.insert({
+        tableName: storage.TABLE_THREADS,
+        record: {
+          ...thread,
+          metadata: JSON.stringify(thread.metadata)
+        }
+      });
+      return thread;
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "LIBSQL_STORE_SAVE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId: thread.id }
+        },
+        error$1
+      );
+      this.logger?.trackException?.(mastraError);
+      this.logger?.error?.(mastraError.toString());
       throw mastraError;
     }
   }
@@ -1346,281 +1712,342 @@ var LibSQLStore = class extends storage.MastraStorage {
       );
     }
   }
-  async deleteThread({ threadId }) {
-    try {
-      await this.client.execute({
-        sql: `DELETE FROM ${storage.TABLE_MESSAGES} WHERE thread_id = ?`,
-        args: [threadId]
-      });
-      await this.client.execute({
-        sql: `DELETE FROM ${storage.TABLE_THREADS} WHERE id = ?`,
-        args: [threadId]
-      });
-    } catch (error$1) {
+  async deleteThread({ threadId }) {
+    try {
+      await this.client.execute({
+        sql: `DELETE FROM ${storage.TABLE_MESSAGES} WHERE thread_id = ?`,
+        args: [threadId]
+      });
+      await this.client.execute({
+        sql: `DELETE FROM ${storage.TABLE_THREADS} WHERE id = ?`,
+        args: [threadId]
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LIBSQL_STORE_DELETE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error$1
+      );
+    }
+  }
+};
+function createExecuteWriteOperationWithRetry({
+  logger,
+  maxRetries,
+  initialBackoffMs
+}) {
+  return async function executeWriteOperationWithRetry(operationFn, operationDescription) {
+    let retries = 0;
+    while (true) {
+      try {
+        return await operationFn();
+      } catch (error) {
+        if (error.message && (error.message.includes("SQLITE_BUSY") || error.message.includes("database is locked")) && retries < maxRetries) {
+          retries++;
+          const backoffTime = initialBackoffMs * Math.pow(2, retries - 1);
+          logger.warn(
+            `LibSQLStore: Encountered SQLITE_BUSY during ${operationDescription}. Retrying (${retries}/${maxRetries}) in ${backoffTime}ms...`
+          );
+          await new Promise((resolve) => setTimeout(resolve, backoffTime));
+        } else {
+          logger.error(`LibSQLStore: Error during ${operationDescription} after ${retries} retries: ${error}`);
+          throw error;
+        }
+      }
+    }
+  };
+}
+function prepareStatement({ tableName, record }) {
+  const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+  const columns = Object.keys(record).map((col) => utils.parseSqlIdentifier(col, "column name"));
+  const values = Object.values(record).map((v) => {
+    if (typeof v === `undefined`) {
+      return null;
+    }
+    if (v instanceof Date) {
+      return v.toISOString();
+    }
+    return typeof v === "object" ? JSON.stringify(v) : v;
+  });
+  const placeholders = values.map(() => "?").join(", ");
+  return {
+    sql: `INSERT OR REPLACE INTO ${parsedTableName} (${columns.join(", ")}) VALUES (${placeholders})`,
+    args: values
+  };
+}
+
+// src/storage/domains/operations/index.ts
+var StoreOperationsLibSQL = class extends storage.StoreOperations {
+  client;
+  /**
+   * Maximum number of retries for write operations if an SQLITE_BUSY error occurs.
+   * @default 5
+   */
+  maxRetries;
+  /**
+   * Initial backoff time in milliseconds for retrying write operations on SQLITE_BUSY.
+   * The backoff time will double with each retry (exponential backoff).
+   * @default 100
+   */
+  initialBackoffMs;
+  constructor({
+    client,
+    maxRetries,
+    initialBackoffMs
+  }) {
+    super();
+    this.client = client;
+    this.maxRetries = maxRetries ?? 5;
+    this.initialBackoffMs = initialBackoffMs ?? 100;
+  }
+  async hasColumn(table, column) {
+    const result = await this.client.execute({
+      sql: `PRAGMA table_info(${table})`
+    });
+    return (await result.rows)?.some((row) => row.name === column);
+  }
+  getCreateTableSQL(tableName, schema) {
+    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+    const columns = Object.entries(schema).map(([name, col]) => {
+      const parsedColumnName = utils.parseSqlIdentifier(name, "column name");
+      let type = col.type.toUpperCase();
+      if (type === "TEXT") type = "TEXT";
+      if (type === "TIMESTAMP") type = "TEXT";
+      const nullable = col.nullable ? "" : "NOT NULL";
+      const primaryKey = col.primaryKey ? "PRIMARY KEY" : "";
+      return `${parsedColumnName} ${type} ${nullable} ${primaryKey}`.trim();
+    });
+    if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
+      const stmnt = `CREATE TABLE IF NOT EXISTS ${parsedTableName} (
+                    ${columns.join(",\n")},
+                    PRIMARY KEY (workflow_name, run_id)
+                )`;
+      return stmnt;
+    }
+    return `CREATE TABLE IF NOT EXISTS ${parsedTableName} (${columns.join(", ")})`;
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    try {
+      this.logger.debug(`Creating database table`, { tableName, operation: "schema init" });
+      const sql = this.getCreateTableSQL(tableName, schema);
+      await this.client.execute(sql);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LIBSQL_STORE_CREATE_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  getSqlType(type) {
+    switch (type) {
+      case "bigint":
+        return "INTEGER";
+      // SQLite uses INTEGER for all integer sizes
+      case "jsonb":
+        return "TEXT";
+      // Store JSON as TEXT in SQLite
+      default:
+        return super.getSqlType(type);
+    }
+  }
+  async doInsert({
+    tableName,
+    record
+  }) {
+    await this.client.execute(
+      prepareStatement({
+        tableName,
+        record
+      })
+    );
+  }
+  insert(args) {
+    const executeWriteOperationWithRetry = createExecuteWriteOperationWithRetry({
+      logger: this.logger,
+      maxRetries: this.maxRetries,
+      initialBackoffMs: this.initialBackoffMs
+    });
+    return executeWriteOperationWithRetry(() => this.doInsert(args), `insert into table ${args.tableName}`);
+  }
+  async load({ tableName, keys }) {
+    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+    const parsedKeys = Object.keys(keys).map((key) => utils.parseSqlIdentifier(key, "column name"));
+    const conditions = parsedKeys.map((key) => `${key} = ?`).join(" AND ");
+    const values = Object.values(keys);
+    const result = await this.client.execute({
+      sql: `SELECT * FROM ${parsedTableName} WHERE ${conditions} ORDER BY createdAt DESC LIMIT 1`,
+      args: values
+    });
+    if (!result.rows || result.rows.length === 0) {
+      return null;
+    }
+    const row = result.rows[0];
+    const parsed = Object.fromEntries(
+      Object.entries(row || {}).map(([k, v]) => {
+        try {
+          return [k, typeof v === "string" ? v.startsWith("{") || v.startsWith("[") ? JSON.parse(v) : v : v];
+        } catch {
+          return [k, v];
+        }
+      })
+    );
+    return parsed;
+  }
+  async doBatchInsert({
+    tableName,
+    records
+  }) {
+    if (records.length === 0) return;
+    const batchStatements = records.map((r) => prepareStatement({ tableName, record: r }));
+    await this.client.batch(batchStatements, "write");
+  }
+  batchInsert(args) {
+    const executeWriteOperationWithRetry = createExecuteWriteOperationWithRetry({
+      logger: this.logger,
+      maxRetries: this.maxRetries,
+      initialBackoffMs: this.initialBackoffMs
+    });
+    return executeWriteOperationWithRetry(
+      () => this.doBatchInsert(args),
+      `batch insert into table ${args.tableName}`
+    ).catch((error$1) => {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_DELETE_THREAD_FAILED",
+          id: "LIBSQL_STORE_BATCH_INSERT_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: {
+            tableName: args.tableName
+          }
         },
         error$1
       );
-    }
-  }
-  parseRow(row) {
-    let content = row.content;
-    try {
-      content = JSON.parse(row.content);
-    } catch {
-    }
-    const result = {
-      id: row.id,
-      content,
-      role: row.role,
-      createdAt: new Date(row.createdAt),
-      threadId: row.thread_id,
-      resourceId: row.resourceId
-    };
-    if (row.type && row.type !== `v2`) result.type = row.type;
-    return result;
-  }
-  async _getIncludedMessages({
-    threadId,
-    selectBy
-  }) {
-    const include = selectBy?.include;
-    if (!include) return null;
-    const unionQueries = [];
-    const params = [];
-    for (const inc of include) {
-      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
-      const searchId = inc.threadId || threadId;
-      unionQueries.push(
-        `
-            SELECT * FROM (
-              WITH numbered_messages AS (
-                SELECT
-                  id, content, role, type, "createdAt", thread_id, "resourceId",
-                  ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
-                FROM "${storage.TABLE_MESSAGES}"
-                WHERE thread_id = ?
-              ),
-              target_positions AS (
-                SELECT row_num as target_pos
-                FROM numbered_messages
-                WHERE id = ?
-              )
-              SELECT DISTINCT m.*
-              FROM numbered_messages m
-              CROSS JOIN target_positions t
-              WHERE m.row_num BETWEEN (t.target_pos - ?) AND (t.target_pos + ?)
-            ) 
-            `
-        // Keep ASC for final sorting after fetching context
-      );
-      params.push(searchId, id, withPreviousMessages, withNextMessages);
-    }
-    const finalQuery = unionQueries.join(" UNION ALL ") + ' ORDER BY "createdAt" ASC';
-    const includedResult = await this.client.execute({ sql: finalQuery, args: params });
-    const includedRows = includedResult.rows?.map((row) => this.parseRow(row));
-    const seen = /* @__PURE__ */ new Set();
-    const dedupedRows = includedRows.filter((row) => {
-      if (seen.has(row.id)) return false;
-      seen.add(row.id);
-      return true;
     });
-    return dedupedRows;
   }
-  async getMessages({
-    threadId,
-    selectBy,
-    format
+  /**
+   * Alters table schema to add columns if they don't exist
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists
   }) {
+    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
     try {
-      const messages = [];
-      const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
-      if (selectBy?.include?.length) {
-        const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
-        if (includeMessages) {
-          messages.push(...includeMessages);
+      const pragmaQuery = `PRAGMA table_info(${parsedTableName})`;
+      const result = await this.client.execute(pragmaQuery);
+      const existingColumnNames = new Set(result.rows.map((row) => row.name.toLowerCase()));
+      for (const columnName of ifNotExists) {
+        if (!existingColumnNames.has(columnName.toLowerCase()) && schema[columnName]) {
+          const columnDef = schema[columnName];
+          const sqlType = this.getSqlType(columnDef.type);
+          const nullable = columnDef.nullable === false ? "NOT NULL" : "";
+          const defaultValue = columnDef.nullable === false ? this.getDefaultValue(columnDef.type) : "";
+          const alterSql = `ALTER TABLE ${parsedTableName} ADD COLUMN "${columnName}" ${sqlType} ${nullable} ${defaultValue}`.trim();
+          await this.client.execute(alterSql);
+          this.logger?.debug?.(`Added column ${columnName} to table ${parsedTableName}`);
         }
       }
-      const excludeIds = messages.map((m) => m.id);
-      const remainingSql = `
-        SELECT 
-          id, 
-          content, 
-          role, 
-          type,
-          "createdAt", 
-          thread_id,
-          "resourceId"
-        FROM "${storage.TABLE_MESSAGES}"
-        WHERE thread_id = ?
-        ${excludeIds.length ? `AND id NOT IN (${excludeIds.map(() => "?").join(", ")})` : ""}
-        ORDER BY "createdAt" DESC
-        LIMIT ?
-      `;
-      const remainingArgs = [threadId, ...excludeIds.length ? excludeIds : [], limit];
-      const remainingResult = await this.client.execute({ sql: remainingSql, args: remainingArgs });
-      if (remainingResult.rows) {
-        messages.push(...remainingResult.rows.map((row) => this.parseRow(row)));
-      }
-      messages.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-      const list = new agent.MessageList().add(messages, "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_GET_MESSAGES_FAILED",
+          id: "LIBSQL_STORE_ALTER_TABLE_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: {
+            tableName
+          }
         },
         error$1
       );
     }
   }
-  async getMessagesPaginated(args) {
-    const { threadId, format, selectBy } = args;
-    const { page = 0, perPage: perPageInput, dateRange } = selectBy?.pagination || {};
-    const perPage = perPageInput !== void 0 ? perPageInput : this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-    const messages = [];
-    if (selectBy?.include?.length) {
-      try {
-        const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
-        if (includeMessages) {
-          messages.push(...includeMessages);
-        }
-      } catch (error$1) {
-        throw new error.MastraError(
-          {
-            id: "LIBSQL_STORE_GET_MESSAGES_PAGINATED_GET_INCLUDE_MESSAGES_FAILED",
-            domain: error.ErrorDomain.STORAGE,
-            category: error.ErrorCategory.THIRD_PARTY,
-            details: { threadId }
-          },
-          error$1
-        );
-      }
-    }
+  async clearTable({ tableName }) {
+    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
     try {
-      const currentOffset = page * perPage;
-      const conditions = [`thread_id = ?`];
-      const queryParams = [threadId];
-      if (fromDate) {
-        conditions.push(`"createdAt" >= ?`);
-        queryParams.push(fromDate.toISOString());
-      }
-      if (toDate) {
-        conditions.push(`"createdAt" <= ?`);
-        queryParams.push(toDate.toISOString());
-      }
-      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-      const countResult = await this.client.execute({
-        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_MESSAGES} ${whereClause}`,
-        args: queryParams
-      });
-      const total = Number(countResult.rows?.[0]?.count ?? 0);
-      if (total === 0 && messages.length === 0) {
-        return {
-          messages: [],
-          total: 0,
-          page,
-          perPage,
-          hasMore: false
-        };
-      }
-      const excludeIds = messages.map((m) => m.id);
-      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + queryParams.length + 1}`).join(", ");
-      const dataResult = await this.client.execute({
-        sql: `SELECT id, content, role, type, "createdAt", "resourceId", "thread_id" FROM ${storage.TABLE_MESSAGES} ${whereClause} ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ""} ORDER BY "createdAt" DESC LIMIT ? OFFSET ?`,
-        args: [...queryParams, ...excludeIds, perPage, currentOffset]
-      });
-      messages.push(...(dataResult.rows || []).map((row) => this.parseRow(row)));
-      const messagesToReturn = format === "v1" ? new agent.MessageList().add(messages, "memory").get.all.v1() : new agent.MessageList().add(messages, "memory").get.all.v2();
-      return {
-        messages: messagesToReturn,
-        total,
-        page,
-        perPage,
-        hasMore: currentOffset + messages.length < total
-      };
-    } catch (error$1) {
+      await this.client.execute(`DELETE FROM ${parsedTableName}`);
+    } catch (e) {
       const mastraError = new error.MastraError(
         {
-          id: "LIBSQL_STORE_GET_MESSAGES_PAGINATED_FAILED",
+          id: "LIBSQL_STORE_CLEAR_TABLE_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: {
+            tableName
+          }
         },
-        error$1
+        e
       );
       this.logger?.trackException?.(mastraError);
       this.logger?.error?.(mastraError.toString());
-      return { messages: [], total: 0, page, perPage, hasMore: false };
     }
   }
-  async saveMessages({
-    messages,
-    format
-  }) {
-    if (messages.length === 0) return messages;
+  async dropTable({ tableName }) {
+    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
     try {
-      const threadId = messages[0]?.threadId;
-      if (!threadId) {
-        throw new Error("Thread ID is required");
-      }
-      const batchStatements = messages.map((message) => {
-        const time = message.createdAt || /* @__PURE__ */ new Date();
-        if (!message.threadId) {
-          throw new Error(
-            `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`
-          );
-        }
-        if (!message.resourceId) {
-          throw new Error(
-            `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`
-          );
-        }
-        return {
-          sql: `INSERT INTO ${storage.TABLE_MESSAGES} (id, thread_id, content, role, type, createdAt, resourceId) 
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-                ON CONFLICT(id) DO UPDATE SET
-                  thread_id=excluded.thread_id,
-                  content=excluded.content,
-                  role=excluded.role,
-                  type=excluded.type,
-                  resourceId=excluded.resourceId
-              `,
-          args: [
-            message.id,
-            message.threadId,
-            typeof message.content === "object" ? JSON.stringify(message.content) : message.content,
-            message.role,
-            message.type || "v2",
-            time instanceof Date ? time.toISOString() : time,
-            message.resourceId
-          ]
-        };
-      });
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      batchStatements.push({
-        sql: `UPDATE ${storage.TABLE_THREADS} SET updatedAt = ? WHERE id = ?`,
-        args: [now, threadId]
+      await this.client.execute(`DROP TABLE IF EXISTS ${parsedTableName}`);
+    } catch (e) {
+      throw new error.MastraError(
+        {
+          id: "LIBSQL_STORE_DROP_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        e
+      );
+    }
+  }
+};
+var ScoresLibSQL = class extends storage.ScoresStorage {
+  operations;
+  client;
+  constructor({ client, operations }) {
+    super();
+    this.operations = operations;
+    this.client = client;
+  }
+  async getScoresByRunId({
+    runId,
+    pagination
+  }) {
+    try {
+      const result = await this.client.execute({
+        sql: `SELECT * FROM ${storage.TABLE_SCORERS} WHERE runId = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        args: [runId, pagination.perPage + 1, pagination.page * pagination.perPage]
       });
-      await this.client.batch(batchStatements, "write");
-      const list = new agent.MessageList().add(messages, "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
+      return {
+        scores: result.rows?.slice(0, pagination.perPage).map((row) => this.transformScoreRow(row)) ?? [],
+        pagination: {
+          total: result.rows?.length ?? 0,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: result.rows?.length > pagination.perPage
+        }
+      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_SAVE_MESSAGES_FAILED",
+          id: "LIBSQL_STORE_GET_SCORES_BY_RUN_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -1628,185 +2055,151 @@ var LibSQLStore = class extends storage.MastraStorage {
       );
     }
   }
-  async updateMessages({
-    messages
+  async getScoresByScorerId({
+    scorerId,
+    entityId,
+    entityType,
+    source,
+    pagination
   }) {
-    if (messages.length === 0) {
-      return [];
-    }
-    const messageIds = messages.map((m) => m.id);
-    const placeholders = messageIds.map(() => "?").join(",");
-    const selectSql = `SELECT * FROM ${storage.TABLE_MESSAGES} WHERE id IN (${placeholders})`;
-    const existingResult = await this.client.execute({ sql: selectSql, args: messageIds });
-    const existingMessages = existingResult.rows.map((row) => this.parseRow(row));
-    if (existingMessages.length === 0) {
-      return [];
-    }
-    const batchStatements = [];
-    const threadIdsToUpdate = /* @__PURE__ */ new Set();
-    const columnMapping = {
-      threadId: "thread_id"
-    };
-    for (const existingMessage of existingMessages) {
-      const updatePayload = messages.find((m) => m.id === existingMessage.id);
-      if (!updatePayload) continue;
-      const { id, ...fieldsToUpdate } = updatePayload;
-      if (Object.keys(fieldsToUpdate).length === 0) continue;
-      threadIdsToUpdate.add(existingMessage.threadId);
-      if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
-        threadIdsToUpdate.add(updatePayload.threadId);
+    try {
+      const conditions = [];
+      const queryParams = [];
+      if (scorerId) {
+        conditions.push(`scorerId = ?`);
+        queryParams.push(scorerId);
       }
-      const setClauses = [];
-      const args = [];
-      const updatableFields = { ...fieldsToUpdate };
-      if (updatableFields.content) {
-        const newContent = {
-          ...existingMessage.content,
-          ...updatableFields.content,
-          // Deep merge metadata if it exists on both
-          ...existingMessage.content?.metadata && updatableFields.content.metadata ? {
-            metadata: {
-              ...existingMessage.content.metadata,
-              ...updatableFields.content.metadata
-            }
-          } : {}
-        };
-        setClauses.push(`${utils.parseSqlIdentifier("content", "column name")} = ?`);
-        args.push(JSON.stringify(newContent));
-        delete updatableFields.content;
+      if (entityId) {
+        conditions.push(`entityId = ?`);
+        queryParams.push(entityId);
       }
-      for (const key in updatableFields) {
-        if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
-          const dbKey = columnMapping[key] || key;
-          setClauses.push(`${utils.parseSqlIdentifier(dbKey, "column name")} = ?`);
-          let value = updatableFields[key];
-          if (typeof value === "object" && value !== null) {
-            value = JSON.stringify(value);
-          }
-          args.push(value);
-        }
+      if (entityType) {
+        conditions.push(`entityType = ?`);
+        queryParams.push(entityType);
       }
-      if (setClauses.length === 0) continue;
-      args.push(id);
-      const sql = `UPDATE ${storage.TABLE_MESSAGES} SET ${setClauses.join(", ")} WHERE id = ?`;
-      batchStatements.push({ sql, args });
-    }
-    if (batchStatements.length === 0) {
-      return existingMessages;
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    for (const threadId of threadIdsToUpdate) {
-      if (threadId) {
-        batchStatements.push({
-          sql: `UPDATE ${storage.TABLE_THREADS} SET updatedAt = ? WHERE id = ?`,
-          args: [now, threadId]
-        });
+      if (source) {
+        conditions.push(`source = ?`);
+        queryParams.push(source);
       }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const result = await this.client.execute({
+        sql: `SELECT * FROM ${storage.TABLE_SCORERS} ${whereClause} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, pagination.perPage + 1, pagination.page * pagination.perPage]
+      });
+      return {
+        scores: result.rows?.slice(0, pagination.perPage).map((row) => this.transformScoreRow(row)) ?? [],
+        pagination: {
+          total: result.rows?.length ?? 0,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: result.rows?.length > pagination.perPage
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LIBSQL_STORE_GET_SCORES_BY_SCORER_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
     }
-    await this.client.batch(batchStatements, "write");
-    const updatedResult = await this.client.execute({ sql: selectSql, args: messageIds });
-    return updatedResult.rows.map((row) => this.parseRow(row));
   }
-  transformEvalRow(row) {
-    const resultValue = JSON.parse(row.result);
-    const testInfoValue = row.test_info ? JSON.parse(row.test_info) : void 0;
-    if (!resultValue || typeof resultValue !== "object" || !("score" in resultValue)) {
-      throw new Error(`Invalid MetricResult format: ${JSON.stringify(resultValue)}`);
-    }
+  transformScoreRow(row) {
+    const scorerValue = storage.safelyParseJSON(row.scorer);
+    const inputValue = storage.safelyParseJSON(row.input ?? "{}");
+    const outputValue = storage.safelyParseJSON(row.output ?? "{}");
+    const additionalLLMContextValue = row.additionalLLMContext ? storage.safelyParseJSON(row.additionalLLMContext) : null;
+    const runtimeContextValue = row.runtimeContext ? storage.safelyParseJSON(row.runtimeContext) : null;
+    const metadataValue = row.metadata ? storage.safelyParseJSON(row.metadata) : null;
+    const entityValue = row.entity ? storage.safelyParseJSON(row.entity) : null;
+    const preprocessStepResultValue = row.preprocessStepResult ? storage.safelyParseJSON(row.preprocessStepResult) : null;
+    const analyzeStepResultValue = row.analyzeStepResult ? storage.safelyParseJSON(row.analyzeStepResult) : null;
     return {
-      input: row.input,
-      output: row.output,
-      result: resultValue,
-      agentName: row.agent_name,
-      metricName: row.metric_name,
-      instructions: row.instructions,
-      testInfo: testInfoValue,
-      globalRunId: row.global_run_id,
-      runId: row.run_id,
-      createdAt: row.created_at
+      id: row.id,
+      traceId: row.traceId,
+      runId: row.runId,
+      scorer: scorerValue,
+      score: row.score,
+      reason: row.reason,
+      preprocessStepResult: preprocessStepResultValue,
+      analyzeStepResult: analyzeStepResultValue,
+      analyzePrompt: row.analyzePrompt,
+      preprocessPrompt: row.preprocessPrompt,
+      generateScorePrompt: row.generateScorePrompt,
+      generateReasonPrompt: row.generateReasonPrompt,
+      metadata: metadataValue,
+      input: inputValue,
+      output: outputValue,
+      additionalContext: additionalLLMContextValue,
+      runtimeContext: runtimeContextValue,
+      entityType: row.entityType,
+      entity: entityValue,
+      entityId: row.entityId,
+      scorerId: row.scorerId,
+      source: row.source,
+      resourceId: row.resourceId,
+      threadId: row.threadId,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
     };
   }
-  /** @deprecated use getEvals instead */
-  async getEvalsByAgentName(agentName, type) {
+  async getScoreById({ id }) {
+    const result = await this.client.execute({
+      sql: `SELECT * FROM ${storage.TABLE_SCORERS} WHERE id = ?`,
+      args: [id]
+    });
+    return result.rows?.[0] ? this.transformScoreRow(result.rows[0]) : null;
+  }
+  async saveScore(score) {
     try {
-      const baseQuery = `SELECT * FROM ${storage.TABLE_EVALS} WHERE agent_name = ?`;
-      const typeCondition = type === "test" ? " AND test_info IS NOT NULL AND test_info->>'testPath' IS NOT NULL" : type === "live" ? " AND (test_info IS NULL OR test_info->>'testPath' IS NULL)" : "";
-      const result = await this.client.execute({
-        sql: `${baseQuery}${typeCondition} ORDER BY created_at DESC`,
-        args: [agentName]
+      const id = crypto.randomUUID();
+      await this.operations.insert({
+        tableName: storage.TABLE_SCORERS,
+        record: {
+          id,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          ...score
+        }
       });
-      return result.rows?.map((row) => this.transformEvalRow(row)) ?? [];
+      const scoreFromDb = await this.getScoreById({ id });
+      return { score: scoreFromDb };
     } catch (error$1) {
-      if (error$1 instanceof Error && error$1.message.includes("no such table")) {
-        return [];
-      }
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_GET_EVALS_BY_AGENT_NAME_FAILED",
+          id: "LIBSQL_STORE_SAVE_SCORE_FAILED",
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { agentName }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
-  async getEvals(options = {}) {
-    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-    const conditions = [];
-    const queryParams = [];
-    if (agentName) {
-      conditions.push(`agent_name = ?`);
-      queryParams.push(agentName);
-    }
-    if (type === "test") {
-      conditions.push(`(test_info IS NOT NULL AND json_extract(test_info, '$.testPath') IS NOT NULL)`);
-    } else if (type === "live") {
-      conditions.push(`(test_info IS NULL OR json_extract(test_info, '$.testPath') IS NULL)`);
-    }
-    if (fromDate) {
-      conditions.push(`created_at >= ?`);
-      queryParams.push(fromDate.toISOString());
-    }
-    if (toDate) {
-      conditions.push(`created_at <= ?`);
-      queryParams.push(toDate.toISOString());
-    }
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
     try {
-      const countResult = await this.client.execute({
-        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_EVALS} ${whereClause}`,
-        args: queryParams
-      });
-      const total = Number(countResult.rows?.[0]?.count ?? 0);
-      const currentOffset = page * perPage;
-      const hasMore = currentOffset + perPage < total;
-      if (total === 0) {
-        return {
-          evals: [],
-          total: 0,
-          page,
-          perPage,
-          hasMore: false
-        };
-      }
-      const dataResult = await this.client.execute({
-        sql: `SELECT * FROM ${storage.TABLE_EVALS} ${whereClause} ORDER BY created_at DESC LIMIT ? OFFSET ?`,
-        args: [...queryParams, perPage, currentOffset]
+      const result = await this.client.execute({
+        sql: `SELECT * FROM ${storage.TABLE_SCORERS} WHERE entityId = ? AND entityType = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        args: [entityId, entityType, pagination.perPage + 1, pagination.page * pagination.perPage]
       });
       return {
-        evals: dataResult.rows?.map((row) => this.transformEvalRow(row)) ?? [],
-        total,
-        page,
-        perPage,
-        hasMore
+        scores: result.rows?.slice(0, pagination.perPage).map((row) => this.transformScoreRow(row)) ?? [],
+        pagination: {
+          total: result.rows?.length ?? 0,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: result.rows?.length > pagination.perPage
+        }
       };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_GET_EVALS_FAILED",
+          id: "LIBSQL_STORE_GET_SCORES_BY_ENTITY_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -1814,9 +2207,15 @@ var LibSQLStore = class extends storage.MastraStorage {
       );
     }
   }
-  /**
-   * @deprecated use getTracesPaginated instead.
-   */
+};
+var TracesLibSQL = class extends storage.TracesStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
   async getTraces(args) {
     if (args.fromDate || args.toDate) {
       args.dateRange = {
@@ -1893,35 +2292,133 @@ var LibSQLStore = class extends storage.MastraStorage {
         sql: `SELECT * FROM ${storage.TABLE_TRACES} ${whereClause} ORDER BY "startTime" DESC LIMIT ? OFFSET ?`,
         args: [...queryArgs, perPage, currentOffset]
       });
-      const traces = dataResult.rows?.map(
-        (row) => ({
-          id: row.id,
-          parentSpanId: row.parentSpanId,
-          traceId: row.traceId,
-          name: row.name,
-          scope: row.scope,
-          kind: row.kind,
-          status: safelyParseJSON(row.status),
-          events: safelyParseJSON(row.events),
-          links: safelyParseJSON(row.links),
-          attributes: safelyParseJSON(row.attributes),
-          startTime: row.startTime,
-          endTime: row.endTime,
-          other: safelyParseJSON(row.other),
-          createdAt: row.createdAt
-        })
-      ) ?? [];
-      return {
-        traces,
-        total,
-        page,
-        perPage,
-        hasMore: currentOffset + traces.length < total
-      };
+      const traces = dataResult.rows?.map(
+        (row) => ({
+          id: row.id,
+          parentSpanId: row.parentSpanId,
+          traceId: row.traceId,
+          name: row.name,
+          scope: row.scope,
+          kind: row.kind,
+          status: storage.safelyParseJSON(row.status),
+          events: storage.safelyParseJSON(row.events),
+          links: storage.safelyParseJSON(row.links),
+          attributes: storage.safelyParseJSON(row.attributes),
+          startTime: row.startTime,
+          endTime: row.endTime,
+          other: storage.safelyParseJSON(row.other),
+          createdAt: row.createdAt
+        })
+      ) ?? [];
+      return {
+        traces,
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + traces.length < total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LIBSQL_STORE_GET_TRACES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async batchTraceInsert({ records }) {
+    this.logger.debug("Batch inserting traces", { count: records.length });
+    await this.operations.batchInsert({
+      tableName: storage.TABLE_TRACES,
+      records
+    });
+  }
+};
+function parseWorkflowRun(row) {
+  let parsedSnapshot = row.snapshot;
+  if (typeof parsedSnapshot === "string") {
+    try {
+      parsedSnapshot = JSON.parse(row.snapshot);
+    } catch (e) {
+      console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+    }
+  }
+  return {
+    workflowName: row.workflow_name,
+    runId: row.run_id,
+    snapshot: parsedSnapshot,
+    resourceId: row.resourceId,
+    createdAt: new Date(row.createdAt),
+    updatedAt: new Date(row.updatedAt)
+  };
+}
+var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
+  operations;
+  client;
+  constructor({ operations, client }) {
+    super();
+    this.operations = operations;
+    this.client = client;
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    const data = {
+      workflow_name: workflowName,
+      run_id: runId,
+      snapshot,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.logger.debug("Persisting workflow snapshot", { workflowName, runId, data });
+    await this.operations.insert({
+      tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+      record: data
+    });
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    this.logger.debug("Loading workflow snapshot", { workflowName, runId });
+    const d = await this.operations.load({
+      tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+      keys: { workflow_name: workflowName, run_id: runId }
+    });
+    return d ? d.snapshot : null;
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    const conditions = [];
+    const args = [];
+    if (runId) {
+      conditions.push("run_id = ?");
+      args.push(runId);
+    }
+    if (workflowName) {
+      conditions.push("workflow_name = ?");
+      args.push(workflowName);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    try {
+      const result = await this.client.execute({
+        sql: `SELECT * FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} ${whereClause}`,
+        args
+      });
+      if (!result.rows?.[0]) {
+        return null;
+      }
+      return parseWorkflowRun(result.rows[0]);
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_GET_TRACES_PAGINATED_FAILED",
+          id: "LIBSQL_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -1953,7 +2450,7 @@ var LibSQLStore = class extends storage.MastraStorage {
         args.push(toDate.toISOString());
       }
       if (resourceId) {
-        const hasResourceId = await this.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
+        const hasResourceId = await this.operations.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
         if (hasResourceId) {
           conditions.push("resourceId = ?");
           args.push(resourceId);
@@ -1974,7 +2471,7 @@ var LibSQLStore = class extends storage.MastraStorage {
         sql: `SELECT * FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} ${whereClause} ORDER BY createdAt DESC${limit !== void 0 && offset !== void 0 ? ` LIMIT ? OFFSET ?` : ""}`,
         args: limit !== void 0 && offset !== void 0 ? [...args, limit, offset] : args
       });
-      const runs = (result.rows || []).map((row) => this.parseWorkflowRun(row));
+      const runs = (result.rows || []).map((row) => parseWorkflowRun(row));
       return { runs, total: total || runs.length };
     } catch (error$1) {
       throw new error.MastraError(
@@ -1987,133 +2484,235 @@ var LibSQLStore = class extends storage.MastraStorage {
       );
     }
   }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
-    const conditions = [];
-    const args = [];
-    if (runId) {
-      conditions.push("run_id = ?");
-      args.push(runId);
-    }
-    if (workflowName) {
-      conditions.push("workflow_name = ?");
-      args.push(workflowName);
-    }
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    try {
-      const result = await this.client.execute({
-        sql: `SELECT * FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} ${whereClause}`,
-        args
+};
+
+// src/storage/index.ts
+var LibSQLStore = class extends storage.MastraStorage {
+  client;
+  maxRetries;
+  initialBackoffMs;
+  stores;
+  constructor(config) {
+    super({ name: `LibSQLStore` });
+    this.maxRetries = config.maxRetries ?? 5;
+    this.initialBackoffMs = config.initialBackoffMs ?? 100;
+    if ("url" in config) {
+      if (config.url.endsWith(":memory:")) {
+        this.shouldCacheInit = false;
+      }
+      this.client = client.createClient({
+        url: config.url,
+        ...config.authToken ? { authToken: config.authToken } : {}
       });
-      if (!result.rows?.[0]) {
-        return null;
+      if (config.url.startsWith("file:") || config.url.includes(":memory:")) {
+        this.client.execute("PRAGMA journal_mode=WAL;").then(() => this.logger.debug("LibSQLStore: PRAGMA journal_mode=WAL set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA journal_mode=WAL.", err));
+        this.client.execute("PRAGMA busy_timeout = 5000;").then(() => this.logger.debug("LibSQLStore: PRAGMA busy_timeout=5000 set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA busy_timeout.", err));
       }
-      return this.parseWorkflowRun(result.rows[0]);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "LIBSQL_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
+    } else {
+      this.client = config.client;
     }
-  }
-  async getResourceById({ resourceId }) {
-    const result = await this.load({
-      tableName: storage.TABLE_RESOURCES,
-      keys: { id: resourceId }
+    const operations = new StoreOperationsLibSQL({
+      client: this.client,
+      maxRetries: this.maxRetries,
+      initialBackoffMs: this.initialBackoffMs
     });
-    if (!result) {
-      return null;
-    }
+    const scores = new ScoresLibSQL({ client: this.client, operations });
+    const traces = new TracesLibSQL({ client: this.client, operations });
+    const workflows = new WorkflowsLibSQL({ client: this.client, operations });
+    const memory = new MemoryLibSQL({ client: this.client, operations });
+    const legacyEvals = new LegacyEvalsLibSQL({ client: this.client });
+    this.stores = {
+      operations,
+      scores,
+      traces,
+      workflows,
+      memory,
+      legacyEvals
+    };
+  }
+  get supports() {
     return {
-      ...result,
-      // Ensure workingMemory is always returned as a string, even if auto-parsed as JSON
-      workingMemory: typeof result.workingMemory === "object" ? JSON.stringify(result.workingMemory) : result.workingMemory,
-      metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: true,
+      createTable: true,
+      deleteMessages: true
     };
   }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    await this.stores.operations.createTable({ tableName, schema });
+  }
+  /**
+   * Alters table schema to add columns if they don't exist
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists
+  }) {
+    await this.stores.operations.alterTable({ tableName, schema, ifNotExists });
+  }
+  async clearTable({ tableName }) {
+    await this.stores.operations.clearTable({ tableName });
+  }
+  async dropTable({ tableName }) {
+    await this.stores.operations.dropTable({ tableName });
+  }
+  insert(args) {
+    return this.stores.operations.insert(args);
+  }
+  batchInsert(args) {
+    return this.stores.operations.batchInsert(args);
+  }
+  async load({ tableName, keys }) {
+    return this.stores.operations.load({ tableName, keys });
+  }
+  async getThreadById({ threadId }) {
+    return this.stores.memory.getThreadById({ threadId });
+  }
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead for paginated results.
+   */
+  async getThreadsByResourceId(args) {
+    return this.stores.memory.getThreadsByResourceId(args);
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    return this.stores.memory.getThreadsByResourceIdPaginated(args);
+  }
+  async saveThread({ thread }) {
+    return this.stores.memory.saveThread({ thread });
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    return this.stores.memory.updateThread({ id, title, metadata });
+  }
+  async deleteThread({ threadId }) {
+    return this.stores.memory.deleteThread({ threadId });
+  }
+  async getMessages({
+    threadId,
+    selectBy,
+    format
+  }) {
+    return this.stores.memory.getMessages({ threadId, selectBy, format });
+  }
+  async getMessagesPaginated(args) {
+    return this.stores.memory.getMessagesPaginated(args);
+  }
+  async saveMessages(args) {
+    return this.stores.memory.saveMessages(args);
+  }
+  async updateMessages({
+    messages
+  }) {
+    return this.stores.memory.updateMessages({ messages });
+  }
+  async deleteMessages(messageIds) {
+    return this.stores.memory.deleteMessages(messageIds);
+  }
+  /** @deprecated use getEvals instead */
+  async getEvalsByAgentName(agentName, type) {
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
+  }
+  async getEvals(options = {}) {
+    return this.stores.legacyEvals.getEvals(options);
+  }
+  async getScoreById({ id }) {
+    return this.stores.scores.getScoreById({ id });
+  }
+  async saveScore(score) {
+    return this.stores.scores.saveScore(score);
+  }
+  async getScoresByScorerId({
+    scorerId,
+    entityId,
+    entityType,
+    source,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByScorerId({ scorerId, entityId, entityType, source, pagination });
+  }
+  async getScoresByRunId({
+    runId,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByRunId({ runId, pagination });
+  }
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByEntityId({ entityId, entityType, pagination });
+  }
+  /**
+   * TRACES
+   */
+  /**
+   * @deprecated use getTracesPaginated instead.
+   */
+  async getTraces(args) {
+    return this.stores.traces.getTraces(args);
+  }
+  async getTracesPaginated(args) {
+    return this.stores.traces.getTracesPaginated(args);
+  }
+  async batchTraceInsert(args) {
+    return this.stores.traces.batchTraceInsert(args);
+  }
+  /**
+   * WORKFLOWS
+   */
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
+  }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset,
+    resourceId
+  } = {}) {
+    return this.stores.workflows.getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId });
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
+  }
+  async getResourceById({ resourceId }) {
+    return this.stores.memory.getResourceById({ resourceId });
+  }
   async saveResource({ resource }) {
-    await this.insert({
-      tableName: storage.TABLE_RESOURCES,
-      record: {
-        ...resource,
-        metadata: JSON.stringify(resource.metadata)
-      }
-    });
-    return resource;
+    return this.stores.memory.saveResource({ resource });
   }
   async updateResource({
     resourceId,
     workingMemory,
     metadata
   }) {
-    const existingResource = await this.getResourceById({ resourceId });
-    if (!existingResource) {
-      const newResource = {
-        id: resourceId,
-        workingMemory,
-        metadata: metadata || {},
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      return this.saveResource({ resource: newResource });
-    }
-    const updatedResource = {
-      ...existingResource,
-      workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
-      metadata: {
-        ...existingResource.metadata,
-        ...metadata
-      },
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    const updates = [];
-    const values = [];
-    if (workingMemory !== void 0) {
-      updates.push("workingMemory = ?");
-      values.push(workingMemory);
-    }
-    if (metadata) {
-      updates.push("metadata = ?");
-      values.push(JSON.stringify(updatedResource.metadata));
-    }
-    updates.push("updatedAt = ?");
-    values.push(updatedResource.updatedAt.toISOString());
-    values.push(resourceId);
-    await this.client.execute({
-      sql: `UPDATE ${storage.TABLE_RESOURCES} SET ${updates.join(", ")} WHERE id = ?`,
-      args: values
-    });
-    return updatedResource;
-  }
-  async hasColumn(table, column) {
-    const result = await this.client.execute({
-      sql: `PRAGMA table_info(${table})`
-    });
-    return (await result.rows)?.some((row) => row.name === column);
-  }
-  parseWorkflowRun(row) {
-    let parsedSnapshot = row.snapshot;
-    if (typeof parsedSnapshot === "string") {
-      try {
-        parsedSnapshot = JSON.parse(row.snapshot);
-      } catch (e) {
-        console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
-      }
-    }
-    return {
-      workflowName: row.workflow_name,
-      runId: row.run_id,
-      snapshot: parsedSnapshot,
-      resourceId: row.resourceId,
-      createdAt: new Date(row.createdAt),
-      updatedAt: new Date(row.updatedAt)
-    };
+    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
   }
 };
 
@@ -2220,3 +2819,5 @@ exports.DefaultStorage = LibSQLStore;
 exports.LIBSQL_PROMPT = LIBSQL_PROMPT;
 exports.LibSQLStore = LibSQLStore;
 exports.LibSQLVector = LibSQLVector;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map