@mastra/libsql 1.0.0-beta.0 → 1.0.0-beta.10

package/dist/index.cjs

@@ -2,10 +2,11 @@
 
 var client = require('@libsql/client');
 var error = require('@mastra/core/error');
+var storage = require('@mastra/core/storage');
 var utils = require('@mastra/core/utils');
 var vector = require('@mastra/core/vector');
 var filter = require('@mastra/core/vector/filter');
-var storage = require('@mastra/core/storage');
+var base = require('@mastra/core/base');
 var agent = require('@mastra/core/agent');
 var evals = require('@mastra/core/evals');
 
@@ -92,12 +93,20 @@ var createBasicOperator = (symbol) => {
   };
 };
 var createNumericOperator = (symbol) => {
-  return (key) => {
+  return (key, value) => {
     const jsonPath = getJsonPath(key);
-    return {
-      sql: `CAST(json_extract(metadata, ${jsonPath}) AS NUMERIC) ${symbol} ?`,
-      needsValue: true
-    };
+    const isNumeric = typeof value === "number" || typeof value === "string" && !isNaN(Number(value)) && value.trim() !== "";
+    if (isNumeric) {
+      return {
+        sql: `CAST(json_extract(metadata, ${jsonPath}) AS NUMERIC) ${symbol} ?`,
+        needsValue: true
+      };
+    } else {
+      return {
+        sql: `CAST(json_extract(metadata, ${jsonPath}) AS TEXT) ${symbol} ?`,
+        needsValue: true
+      };
+    }
   };
 };
 var validateJsonArray = (key) => {
@@ -575,7 +584,7 @@ var LibSQLVector = class extends vector.MastraVector {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_VECTOR_QUERY_INVALID_ARGS",
+          id: storage.createVectorErrorId("LIBSQL", "QUERY", "INVALID_ARGS"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER
         },
@@ -617,7 +626,7 @@ var LibSQLVector = class extends vector.MastraVector {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_VECTOR_QUERY_FAILED",
+          id: storage.createVectorErrorId("LIBSQL", "QUERY", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -631,7 +640,7 @@ var LibSQLVector = class extends vector.MastraVector {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_VECTOR_UPSERT_FAILED",
+          id: storage.createVectorErrorId("LIBSQL", "UPSERT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -685,7 +694,7 @@ var LibSQLVector = class extends vector.MastraVector {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_VECTOR_CREATE_INDEX_FAILED",
+          id: storage.createVectorErrorId("LIBSQL", "CREATE_INDEX", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { indexName: args.indexName, dimension: args.dimension }
@@ -724,7 +733,7 @@ var LibSQLVector = class extends vector.MastraVector {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_VECTOR_DELETE_INDEX_FAILED",
+          id: storage.createVectorErrorId("LIBSQL", "DELETE_INDEX", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { indexName: args.indexName }
@@ -755,7 +764,7 @@ var LibSQLVector = class extends vector.MastraVector {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_VECTOR_LIST_INDEXES_FAILED",
+          id: storage.createVectorErrorId("LIBSQL", "LIST_INDEXES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -803,7 +812,7 @@ var LibSQLVector = class extends vector.MastraVector {
     } catch (e) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_VECTOR_DESCRIBE_INDEX_FAILED",
+          id: storage.createVectorErrorId("LIBSQL", "DESCRIBE_INDEX", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { indexName }
@@ -826,8 +835,27 @@ var LibSQLVector = class extends vector.MastraVector {
   updateVector(args) {
     return this.executeWriteOperationWithRetry(() => this.doUpdateVector(args));
   }
-  async doUpdateVector({ indexName, id, update }) {
+  async doUpdateVector(params) {
+    const { indexName, update } = params;
     const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
+    if ("id" in params && params.id && "filter" in params && params.filter) {
+      throw new error.MastraError({
+        id: storage.createVectorErrorId("LIBSQL", "UPDATE_VECTOR", "MUTUALLY_EXCLUSIVE"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { indexName },
+        text: "id and filter are mutually exclusive - provide only one"
+      });
+    }
+    if (!update.vector && !update.metadata) {
+      throw new error.MastraError({
+        id: storage.createVectorErrorId("LIBSQL", "UPDATE_VECTOR", "NO_PAYLOAD"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { indexName },
+        text: "No updates provided"
+      });
+    }
     const updates = [];
     const args = [];
     if (update.vector) {
@@ -839,32 +867,81 @@ var LibSQLVector = class extends vector.MastraVector {
       args.push(JSON.stringify(update.metadata));
     }
     if (updates.length === 0) {
+      return;
+    }
+    let whereClause;
+    let whereValues;
+    if ("id" in params && params.id) {
+      whereClause = "vector_id = ?";
+      whereValues = [params.id];
+    } else if ("filter" in params && params.filter) {
+      const filter = params.filter;
+      if (!filter || Object.keys(filter).length === 0) {
+        throw new error.MastraError({
+          id: storage.createVectorErrorId("LIBSQL", "UPDATE_VECTOR", "EMPTY_FILTER"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName },
+          text: "Cannot update with empty filter"
+        });
+      }
+      const translatedFilter = this.transformFilter(filter);
+      const { sql: filterSql, values: filterValues } = buildFilterQuery(translatedFilter);
+      if (!filterSql || filterSql.trim() === "") {
+        throw new error.MastraError({
+          id: storage.createVectorErrorId("LIBSQL", "UPDATE_VECTOR", "INVALID_FILTER"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName },
+          text: "Filter produced empty WHERE clause"
+        });
+      }
+      const normalizedCondition = filterSql.replace(/^\s*WHERE\s+/i, "").trim().toLowerCase();
+      const matchAllPatterns = ["true", "1 = 1", "1=1"];
+      if (matchAllPatterns.includes(normalizedCondition)) {
+        throw new error.MastraError({
+          id: storage.createVectorErrorId("LIBSQL", "UPDATE_VECTOR", "MATCH_ALL_FILTER"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName, filterSql: normalizedCondition },
+          text: "Filter matches all vectors. Provide a specific filter to update targeted vectors."
+        });
+      }
+      whereClause = filterSql.replace(/^WHERE\s+/i, "");
+      whereValues = filterValues;
+    } else {
       throw new error.MastraError({
-        id: "LIBSQL_VECTOR_UPDATE_VECTOR_INVALID_ARGS",
+        id: storage.createVectorErrorId("LIBSQL", "UPDATE_VECTOR", "NO_TARGET"),
         domain: error.ErrorDomain.STORAGE,
         category: error.ErrorCategory.USER,
-        details: { indexName, id },
-        text: "No updates provided"
+        details: { indexName },
+        text: "Either id or filter must be provided"
       });
     }
-    args.push(id);
     const query = `
-        UPDATE ${parsedIndexName}
-        SET ${updates.join(", ")}
-        WHERE vector_id = ?;
-      `;
+      UPDATE ${parsedIndexName}
+      SET ${updates.join(", ")}
+      WHERE ${whereClause};
+    `;
     try {
       await this.turso.execute({
         sql: query,
-        args
+        args: [...args, ...whereValues]
       });
     } catch (error$1) {
+      const errorDetails = { indexName };
+      if ("id" in params && params.id) {
+        errorDetails.id = params.id;
+      }
+      if ("filter" in params && params.filter) {
+        errorDetails.filter = JSON.stringify(params.filter);
+      }
       throw new error.MastraError(
         {
-          id: "LIBSQL_VECTOR_UPDATE_VECTOR_FAILED",
+          id: storage.createVectorErrorId("LIBSQL", "UPDATE_VECTOR", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName, id }
+          details: errorDetails
         },
         error$1
       );
@@ -883,10 +960,13 @@ var LibSQLVector = class extends vector.MastraVector {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_VECTOR_DELETE_VECTOR_FAILED",
+          id: storage.createVectorErrorId("LIBSQL", "DELETE_VECTOR", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { indexName: args.indexName, id: args.id }
+          details: {
+            indexName: args.indexName,
+            ...args.id && { id: args.id }
+          }
         },
         error$1
       );
@@ -899,13 +979,107 @@ var LibSQLVector = class extends vector.MastraVector {
       args: [id]
     });
   }
+  deleteVectors(args) {
+    return this.executeWriteOperationWithRetry(() => this.doDeleteVectors(args));
+  }
+  async doDeleteVectors({ indexName, filter, ids }) {
+    const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
+    if (!filter && !ids) {
+      throw new error.MastraError({
+        id: storage.createVectorErrorId("LIBSQL", "DELETE_VECTORS", "NO_TARGET"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { indexName },
+        text: "Either filter or ids must be provided"
+      });
+    }
+    if (filter && ids) {
+      throw new error.MastraError({
+        id: storage.createVectorErrorId("LIBSQL", "DELETE_VECTORS", "MUTUALLY_EXCLUSIVE"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { indexName },
+        text: "Cannot provide both filter and ids - they are mutually exclusive"
+      });
+    }
+    let query;
+    let values;
+    if (ids) {
+      if (ids.length === 0) {
+        throw new error.MastraError({
+          id: storage.createVectorErrorId("LIBSQL", "DELETE_VECTORS", "EMPTY_IDS"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName },
+          text: "Cannot delete with empty ids array"
+        });
+      }
+      const placeholders = ids.map(() => "?").join(", ");
+      query = `DELETE FROM ${parsedIndexName} WHERE vector_id IN (${placeholders})`;
+      values = ids;
+    } else {
+      if (!filter || Object.keys(filter).length === 0) {
+        throw new error.MastraError({
+          id: storage.createVectorErrorId("LIBSQL", "DELETE_VECTORS", "EMPTY_FILTER"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName },
+          text: "Cannot delete with empty filter. Use deleteIndex to delete all vectors."
+        });
+      }
+      const translatedFilter = this.transformFilter(filter);
+      const { sql: filterSql, values: filterValues } = buildFilterQuery(translatedFilter);
+      if (!filterSql || filterSql.trim() === "") {
+        throw new error.MastraError({
+          id: storage.createVectorErrorId("LIBSQL", "DELETE_VECTORS", "INVALID_FILTER"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName },
+          text: "Filter produced empty WHERE clause"
+        });
+      }
+      const normalizedCondition = filterSql.replace(/^\s*WHERE\s+/i, "").trim().toLowerCase();
+      const matchAllPatterns = ["true", "1 = 1", "1=1"];
+      if (matchAllPatterns.includes(normalizedCondition)) {
+        throw new error.MastraError({
+          id: storage.createVectorErrorId("LIBSQL", "DELETE_VECTORS", "MATCH_ALL_FILTER"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName, filterSql: normalizedCondition },
+          text: "Filter matches all vectors. Use deleteIndex to delete all vectors from an index."
+        });
+      }
+      query = `DELETE FROM ${parsedIndexName} ${filterSql}`;
+      values = filterValues;
+    }
+    try {
+      await this.turso.execute({
+        sql: query,
+        args: values
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createVectorErrorId("LIBSQL", "DELETE_VECTORS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            ...filter && { filter: JSON.stringify(filter) },
+            ...ids && { idsCount: ids.length }
+          }
+        },
+        error$1
+      );
+    }
+  }
   truncateIndex(args) {
     try {
       return this.executeWriteOperationWithRetry(() => this._doTruncateIndex(args));
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_VECTOR_TRUNCATE_INDEX_FAILED",
+          id: storage.createVectorErrorId("LIBSQL", "TRUNCATE_INDEX", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { indexName: args.indexName }
@@ -921,538 +1095,920 @@ var LibSQLVector = class extends vector.MastraVector {
     });
   }
 };
-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 {
-      content = JSON.parse(row.content);
-    } catch {
+function isLockError(error) {
+  return error.code === "SQLITE_BUSY" || error.code === "SQLITE_LOCKED" || error.message?.toLowerCase().includes("database is locked") || error.message?.toLowerCase().includes("database table is locked") || error.message?.toLowerCase().includes("table is locked") || error.constructor.name === "SqliteError" && error.message?.toLowerCase().includes("locked");
+}
+function createExecuteWriteOperationWithRetry({
+  logger,
+  maxRetries,
+  initialBackoffMs
+}) {
+  return async function executeWriteOperationWithRetry(operationFn, operationDescription) {
+    let attempts = 0;
+    let backoff = initialBackoffMs;
+    while (attempts < maxRetries) {
+      try {
+        return await operationFn();
+      } catch (error) {
+        logger.debug(`LibSQLStore: Error caught in retry loop for ${operationDescription}`, {
+          errorType: error.constructor.name,
+          errorCode: error.code,
+          errorMessage: error.message,
+          attempts,
+          maxRetries
+        });
+        if (isLockError(error)) {
+          attempts++;
+          if (attempts >= maxRetries) {
+            logger.error(
+              `LibSQLStore: Operation failed after ${maxRetries} attempts due to database lock: ${error.message}`,
+              { error, attempts, maxRetries }
+            );
+            throw error;
+          }
+          logger.warn(
+            `LibSQLStore: Attempt ${attempts} failed due to database lock during ${operationDescription}. Retrying in ${backoff}ms...`,
+            { errorMessage: error.message, attempts, backoff, maxRetries }
+          );
+          await new Promise((resolve) => setTimeout(resolve, backoff));
+          backoff *= 2;
+        } else {
+          logger.error(`LibSQLStore: Non-lock error during ${operationDescription}, not retrying`, { error });
+          throw error;
+        }
+      }
     }
-    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,
-    include
-  }) {
-    if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-    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);
+    throw new Error(`LibSQLStore: Unexpected exit from retry loop for ${operationDescription}`);
+  };
+}
+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` || v === null) {
+      return null;
     }
-    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 listMessagesById({ messageIds }) {
-    if (messageIds.length === 0) return { messages: [] };
-    try {
-      const sql = `
-        SELECT 
-          id, 
-          content, 
-          role, 
-          type,
-          "createdAt", 
-          thread_id,
-          "resourceId"
-        FROM "${storage.TABLE_MESSAGES}"
-        WHERE id IN (${messageIds.map(() => "?").join(", ")})
-        ORDER BY "createdAt" DESC
-      `;
-      const result = await this.client.execute({ sql, args: messageIds });
-      if (!result.rows) return { messages: [] };
-      const list = new agent.MessageList().add(result.rows.map(this.parseRow), "memory");
-      return { messages: list.get.all.db() };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "LIBSQL_STORE_LIST_MESSAGES_BY_ID_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { messageIds: JSON.stringify(messageIds) }
-        },
-        error$1
-      );
+    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
+  };
+}
+function prepareUpdateStatement({
+  tableName,
+  updates,
+  keys
+}) {
+  const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+  const schema = storage.TABLE_SCHEMAS[tableName];
+  const updateColumns = Object.keys(updates).map((col) => utils.parseSqlIdentifier(col, "column name"));
+  const updateValues = Object.values(updates).map(transformToSqlValue);
+  const setClause = updateColumns.map((col) => `${col} = ?`).join(", ");
+  const whereClause = prepareWhereClause(keys, schema);
+  return {
+    sql: `UPDATE ${parsedTableName} SET ${setClause}${whereClause.sql}`,
+    args: [...updateValues, ...whereClause.args]
+  };
+}
+function transformToSqlValue(value) {
+  if (typeof value === "undefined" || value === null) {
+    return null;
   }
-  async listMessages(args) {
-    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
-    if (!threadId.trim()) {
-      throw new error.MastraError(
-        {
-          id: "STORAGE_LIBSQL_LIST_MESSAGES_INVALID_THREAD_ID",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
-        },
-        new Error("threadId must be a non-empty string")
-      );
-    }
-    if (page < 0) {
-      throw new error.MastraError(
-        {
-          id: "LIBSQL_STORE_LIST_MESSAGES_INVALID_PAGE",
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  return typeof value === "object" ? JSON.stringify(value) : value;
+}
+function prepareDeleteStatement({ tableName, keys }) {
+  const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+  const whereClause = prepareWhereClause(keys, storage.TABLE_SCHEMAS[tableName]);
+  return {
+    sql: `DELETE FROM ${parsedTableName}${whereClause.sql}`,
+    args: whereClause.args
+  };
+}
+function prepareWhereClause(filters, schema) {
+  const conditions = [];
+  const args = [];
+  for (const [columnName, filterValue] of Object.entries(filters)) {
+    const column = schema[columnName];
+    if (!column) {
+      throw new Error(`Unknown column: ${columnName}`);
+    }
+    const parsedColumn = utils.parseSqlIdentifier(columnName, "column name");
+    const result = buildCondition2(parsedColumn, filterValue);
+    conditions.push(result.condition);
+    args.push(...result.args);
+  }
+  return {
+    sql: conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "",
+    args
+  };
+}
+function buildCondition2(columnName, filterValue) {
+  if (filterValue === null) {
+    return { condition: `${columnName} IS NULL`, args: [] };
+  }
+  if (typeof filterValue === "object" && filterValue !== null && ("startAt" in filterValue || "endAt" in filterValue)) {
+    return buildDateRangeCondition(columnName, filterValue);
+  }
+  return {
+    condition: `${columnName} = ?`,
+    args: [transformToSqlValue(filterValue)]
+  };
+}
+function buildDateRangeCondition(columnName, range) {
+  const conditions = [];
+  const args = [];
+  if (range.startAt !== void 0) {
+    conditions.push(`${columnName} >= ?`);
+    args.push(transformToSqlValue(range.startAt));
+  }
+  if (range.endAt !== void 0) {
+    conditions.push(`${columnName} <= ?`);
+    args.push(transformToSqlValue(range.endAt));
+  }
+  if (conditions.length === 0) {
+    throw new Error("Date range must specify at least startAt or endAt");
+  }
+  return {
+    condition: conditions.join(" AND "),
+    args
+  };
+}
+function transformFromSqlRow({
+  tableName,
+  sqlRow
+}) {
+  const result = {};
+  const jsonColumns = new Set(
+    Object.keys(storage.TABLE_SCHEMAS[tableName]).filter((key) => storage.TABLE_SCHEMAS[tableName][key].type === "jsonb").map((key) => key)
+  );
+  const dateColumns = new Set(
+    Object.keys(storage.TABLE_SCHEMAS[tableName]).filter((key) => storage.TABLE_SCHEMAS[tableName][key].type === "timestamp").map((key) => key)
+  );
+  for (const [key, value] of Object.entries(sqlRow)) {
+    if (value === null || value === void 0) {
+      result[key] = value;
+      continue;
+    }
+    if (dateColumns.has(key) && typeof value === "string") {
+      result[key] = new Date(value);
+      continue;
+    }
+    if (jsonColumns.has(key) && typeof value === "string") {
+      result[key] = storage.safelyParseJSON(value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+
+// src/storage/db/index.ts
+function resolveClient(config) {
+  if ("client" in config) {
+    return config.client;
+  }
+  return client.createClient({
+    url: config.url,
+    ...config.authToken ? { authToken: config.authToken } : {}
+  });
+}
+var LibSQLDB = class extends base.MastraBase {
+  client;
+  maxRetries;
+  initialBackoffMs;
+  executeWriteOperationWithRetry;
+  constructor({
+    client,
+    maxRetries,
+    initialBackoffMs
+  }) {
+    super({
+      component: "STORAGE",
+      name: "LIBSQL_DB_LAYER"
+    });
+    this.client = client;
+    this.maxRetries = maxRetries ?? 5;
+    this.initialBackoffMs = initialBackoffMs ?? 100;
+    this.executeWriteOperationWithRetry = createExecuteWriteOperationWithRetry({
+      logger: this.logger,
+      maxRetries: this.maxRetries,
+      initialBackoffMs: this.initialBackoffMs
+    });
+  }
+  /**
+   * Checks if a column exists in the specified table.
+   *
+   * @param table - The name of the table to check
+   * @param column - The name of the column to look for
+   * @returns `true` if the column exists in the table, `false` otherwise
+   */
+  async hasColumn(table, column) {
+    const sanitizedTable = utils.parseSqlIdentifier(table, "table name");
+    const result = await this.client.execute({
+      sql: `PRAGMA table_info("${sanitizedTable}")`
+    });
+    return result.rows?.some((row) => row.name === column);
+  }
+  /**
+   * Internal insert implementation without retry logic.
+   */
+  async doInsert({
+    tableName,
+    record
+  }) {
+    await this.client.execute(
+      prepareStatement({
+        tableName,
+        record
+      })
+    );
+  }
+  /**
+   * Inserts or replaces a record in the specified table with automatic retry on lock errors.
+   *
+   * @param args - The insert arguments
+   * @param args.tableName - The name of the table to insert into
+   * @param args.record - The record to insert (key-value pairs)
+   */
+  insert(args) {
+    return this.executeWriteOperationWithRetry(() => this.doInsert(args), `insert into table ${args.tableName}`);
+  }
+  /**
+   * Internal update implementation without retry logic.
+   */
+  async doUpdate({
+    tableName,
+    keys,
+    data
+  }) {
+    await this.client.execute(prepareUpdateStatement({ tableName, updates: data, keys }));
+  }
+  /**
+   * Updates a record in the specified table with automatic retry on lock errors.
+   *
+   * @param args - The update arguments
+   * @param args.tableName - The name of the table to update
+   * @param args.keys - The key(s) identifying the record to update
+   * @param args.data - The fields to update (key-value pairs)
+   */
+  update(args) {
+    return this.executeWriteOperationWithRetry(() => this.doUpdate(args), `update table ${args.tableName}`);
+  }
+  /**
+   * Internal batch insert implementation without retry logic.
+   */
+  async doBatchInsert({
+    tableName,
+    records
+  }) {
+    if (records.length === 0) return;
+    const batchStatements = records.map((r) => prepareStatement({ tableName, record: r }));
+    await this.client.batch(batchStatements, "write");
+  }
+  /**
+   * Inserts multiple records in a single batch transaction with automatic retry on lock errors.
+   *
+   * @param args - The batch insert arguments
+   * @param args.tableName - The name of the table to insert into
+   * @param args.records - Array of records to insert
+   * @throws {MastraError} When the batch insert fails after retries
+   */
+  async batchInsert(args) {
+    return this.executeWriteOperationWithRetry(
+      () => this.doBatchInsert(args),
+      `batch insert into table ${args.tableName}`
+    ).catch((error$1) => {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "BATCH_INSERT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: { page }
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName: args.tableName
+          }
         },
-        new Error("page must be >= 0")
+        error$1
       );
-    }
-    const perPage = storage.normalizePerPage(perPageInput, 40);
-    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-    try {
-      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
-      const orderByStatement = `ORDER BY "${field}" ${direction}`;
-      const conditions = [`thread_id = ?`];
-      const queryParams = [threadId];
-      if (resourceId) {
-        conditions.push(`"resourceId" = ?`);
-        queryParams.push(resourceId);
-      }
-      if (filter?.dateRange?.start) {
-        conditions.push(`"createdAt" >= ?`);
-        queryParams.push(
-          filter.dateRange.start instanceof Date ? filter.dateRange.start.toISOString() : filter.dateRange.start
-        );
-      }
-      if (filter?.dateRange?.end) {
-        conditions.push(`"createdAt" <= ?`);
-        queryParams.push(
-          filter.dateRange.end instanceof Date ? filter.dateRange.end.toISOString() : filter.dateRange.end
+    });
+  }
+  /**
+   * Internal batch update implementation without retry logic.
+   * Each record can be updated based on single or composite keys.
+   */
+  async doBatchUpdate({
+    tableName,
+    updates
+  }) {
+    if (updates.length === 0) return;
+    const batchStatements = updates.map(
+      ({ keys, data }) => prepareUpdateStatement({
+        tableName,
+        updates: data,
+        keys
+      })
+    );
+    await this.client.batch(batchStatements, "write");
+  }
+  /**
+   * Updates multiple records in a single batch transaction with automatic retry on lock errors.
+   * Each record can be updated based on single or composite keys.
+   *
+   * @param args - The batch update arguments
+   * @param args.tableName - The name of the table to update
+   * @param args.updates - Array of update operations, each containing keys and data
+   * @throws {MastraError} When the batch update fails after retries
+   */
+  async batchUpdate(args) {
+    return this.executeWriteOperationWithRetry(
+      () => this.doBatchUpdate(args),
+      `batch update in table ${args.tableName}`
+    ).catch((error$1) => {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "BATCH_UPDATE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName: args.tableName
+          }
+        },
+        error$1
+      );
+    });
+  }
+  /**
+   * Internal batch delete implementation without retry logic.
+   * Each record can be deleted based on single or composite keys.
+   */
+  async doBatchDelete({
+    tableName,
+    keys
+  }) {
+    if (keys.length === 0) return;
+    const batchStatements = keys.map(
+      (keyObj) => prepareDeleteStatement({
+        tableName,
+        keys: keyObj
+      })
+    );
+    await this.client.batch(batchStatements, "write");
+  }
+  /**
+   * Deletes multiple records in a single batch transaction with automatic retry on lock errors.
+   * Each record can be deleted based on single or composite keys.
+   *
+   * @param args - The batch delete arguments
+   * @param args.tableName - The name of the table to delete from
+   * @param args.keys - Array of key objects identifying records to delete
+   * @throws {MastraError} When the batch delete fails after retries
+   */
+  async batchDelete({
+    tableName,
+    keys
+  }) {
+    return this.executeWriteOperationWithRetry(
+      () => this.doBatchDelete({ tableName, keys }),
+      `batch delete from table ${tableName}`
+    ).catch((error$1) => {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "BATCH_DELETE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    });
+  }
+  /**
+   * Internal single-record delete implementation without retry logic.
+   */
+  async doDelete({ tableName, keys }) {
+    await this.client.execute(prepareDeleteStatement({ tableName, keys }));
+  }
+  /**
+   * Deletes a single record from the specified table with automatic retry on lock errors.
+   *
+   * @param args - The delete arguments
+   * @param args.tableName - The name of the table to delete from
+   * @param args.keys - The key(s) identifying the record to delete
+   * @throws {MastraError} When the delete fails after retries
+   */
+  async delete(args) {
+    return this.executeWriteOperationWithRetry(() => this.doDelete(args), `delete from table ${args.tableName}`).catch(
+      (error$1) => {
+        throw new error.MastraError(
+          {
+            id: storage.createStorageErrorId("LIBSQL", "DELETE", "FAILED"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.THIRD_PARTY,
+            details: {
+              tableName: args.tableName
+            }
+          },
+          error$1
         );
       }
-      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);
-      const limitValue = perPageInput === false ? total : perPage;
-      const dataResult = await this.client.execute({
-        sql: `SELECT id, content, role, type, "createdAt", "resourceId", "thread_id" FROM ${storage.TABLE_MESSAGES} ${whereClause} ${orderByStatement} LIMIT ? OFFSET ?`,
-        args: [...queryParams, limitValue, offset]
+    );
+  }
+  /**
+   * Selects a single record from the specified table by key(s).
+   * Returns the most recently created record if multiple matches exist.
+   * Automatically parses JSON string values back to objects/arrays.
+   *
+   * @typeParam R - The expected return type of the record
+   * @param args - The select arguments
+   * @param args.tableName - The name of the table to select from
+   * @param args.keys - The key(s) identifying the record to select
+   * @returns The matching record or `null` if not found
+   */
+  async select({ 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;
+  }
+  /**
+   * Selects multiple records from the specified table with optional filtering, ordering, and pagination.
+   *
+   * @typeParam R - The expected return type of each record
+   * @param args - The select arguments
+   * @param args.tableName - The name of the table to select from
+   * @param args.whereClause - Optional WHERE clause with SQL string and arguments
+   * @param args.orderBy - Optional ORDER BY clause (e.g., "createdAt DESC")
+   * @param args.offset - Optional offset for pagination
+   * @param args.limit - Optional limit for pagination
+   * @param args.args - Optional additional query arguments
+   * @returns Array of matching records
+   */
+  async selectMany({
+    tableName,
+    whereClause,
+    orderBy,
+    offset,
+    limit,
+    args
+  }) {
+    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+    let statement = `SELECT * FROM ${parsedTableName}`;
+    if (whereClause?.sql) {
+      statement += ` ${whereClause.sql}`;
+    }
+    if (orderBy) {
+      statement += ` ORDER BY ${orderBy}`;
+    }
+    if (limit) {
+      statement += ` LIMIT ${limit}`;
+    }
+    if (offset) {
+      statement += ` OFFSET ${offset}`;
+    }
+    const result = await this.client.execute({
+      sql: statement,
+      args: [...whereClause?.args ?? [], ...args ?? []]
+    });
+    return result.rows;
+  }
+  /**
+   * Returns the total count of records matching the optional WHERE clause.
+   *
+   * @param args - The count arguments
+   * @param args.tableName - The name of the table to count from
+   * @param args.whereClause - Optional WHERE clause with SQL string and arguments
+   * @returns The total count of matching records
+   */
+  async selectTotalCount({
+    tableName,
+    whereClause
+  }) {
+    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+    const statement = `SELECT COUNT(*) as count FROM ${parsedTableName} ${whereClause ? `${whereClause.sql}` : ""}`;
+    const result = await this.client.execute({
+      sql: statement,
+      args: whereClause?.args ?? []
+    });
+    if (!result.rows || result.rows.length === 0) {
+      return 0;
+    }
+    return result.rows[0]?.count ?? 0;
+  }
+  /**
+   * Maps a storage column type to its SQLite equivalent.
+   */
+  getSqlType(type) {
+    switch (type) {
+      case "bigint":
+        return "INTEGER";
+      // SQLite uses INTEGER for all integer sizes
+      case "timestamp":
+        return "TEXT";
+      // Store timestamps as ISO strings in SQLite
+      case "float":
+        return "REAL";
+      // SQLite's floating point type
+      case "boolean":
+        return "INTEGER";
+      // SQLite uses 0/1 for booleans
+      case "jsonb":
+        return "TEXT";
+      // Store JSON as TEXT in SQLite
+      default:
+        return storage.getSqlType(type);
+    }
+  }
+  /**
+   * Creates a table if it doesn't exist based on the provided schema.
+   *
+   * @param args - The create table arguments
+   * @param args.tableName - The name of the table to create
+   * @param args.schema - The schema definition for the table columns
+   */
+  async createTable({
+    tableName,
+    schema
+  }) {
+    try {
+      const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+      const columnDefinitions = Object.entries(schema).map(([colName, colDef]) => {
+        const type = this.getSqlType(colDef.type);
+        const nullable = colDef.nullable === false ? "NOT NULL" : "";
+        const primaryKey = colDef.primaryKey ? "PRIMARY KEY" : "";
+        return `"${colName}" ${type} ${nullable} ${primaryKey}`.trim();
       });
-      const messages = (dataResult.rows || []).map((row) => this.parseRow(row));
-      if (total === 0 && messages.length === 0 && (!include || include.length === 0)) {
-        return {
-          messages: [],
-          total: 0,
-          page,
-          perPage: perPageForResponse,
-          hasMore: false
-        };
+      const tableConstraints = [];
+      if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
+        tableConstraints.push("UNIQUE (workflow_name, run_id)");
       }
-      const messageIds = new Set(messages.map((m) => m.id));
-      if (include && include.length > 0) {
-        const includeMessages = await this._getIncludedMessages({ threadId, include });
-        if (includeMessages) {
-          for (const includeMsg of includeMessages) {
-            if (!messageIds.has(includeMsg.id)) {
-              messages.push(includeMsg);
-              messageIds.add(includeMsg.id);
-            }
-          }
-        }
+      const allDefinitions = [...columnDefinitions, ...tableConstraints].join(",\n  ");
+      const sql = `CREATE TABLE IF NOT EXISTS ${parsedTableName} (
+  ${allDefinitions}
+)`;
+      await this.client.execute(sql);
+      this.logger.debug(`LibSQLDB: Created table ${tableName}`);
+      if (tableName === storage.TABLE_SPANS) {
+        await this.migrateSpansTable();
       }
-      const list = new agent.MessageList().add(messages, "memory");
-      let finalMessages = list.get.all.db();
-      finalMessages = finalMessages.sort((a, b) => {
-        const isDateField = field === "createdAt" || field === "updatedAt";
-        const aValue = isDateField ? new Date(a[field]).getTime() : a[field];
-        const bValue = isDateField ? new Date(b[field]).getTime() : b[field];
-        if (typeof aValue === "number" && typeof bValue === "number") {
-          return direction === "ASC" ? aValue - bValue : bValue - aValue;
-        }
-        return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
-      });
-      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
-      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
-      const hasMore = perPageInput !== false && !allThreadMessagesReturned && offset + perPage < total;
-      return {
-        messages: finalMessages,
-        total,
-        page,
-        perPage: perPageForResponse,
-        hasMore
-      };
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_LIST_MESSAGES_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "CREATE_TABLE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId,
-            resourceId: resourceId ?? ""
-          }
+          details: { tableName }
         },
         error$1
       );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException?.(mastraError);
-      return {
-        messages: [],
-        total: 0,
-        page,
-        perPage: perPageForResponse,
-        hasMore: false
-      };
     }
   }
-  async saveMessages({ messages }) {
-    if (messages.length === 0) return { messages };
+  /**
+   * Migrates the spans table schema from OLD_SPAN_SCHEMA to current SPAN_SCHEMA.
+   * This adds new columns that don't exist in old schema.
+   */
+  async migrateSpansTable() {
+    const schema = storage.TABLE_SCHEMAS[storage.TABLE_SPANS];
     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.`
-          );
+      for (const [columnName, columnDef] of Object.entries(schema)) {
+        const columnExists = await this.hasColumn(storage.TABLE_SPANS, columnName);
+        if (!columnExists) {
+          const sqlType = this.getSqlType(columnDef.type);
+          const alterSql = `ALTER TABLE "${storage.TABLE_SPANS}" ADD COLUMN "${columnName}" ${sqlType}`;
+          await this.client.execute(alterSql);
+          this.logger.debug(`LibSQLDB: Added column '${columnName}' to ${storage.TABLE_SPANS}`);
         }
-        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]
+      }
+      this.logger.info(`LibSQLDB: Migration completed for ${storage.TABLE_SPANS}`);
+    } catch (error) {
+      this.logger.warn(`LibSQLDB: Failed to migrate spans table ${storage.TABLE_SPANS}:`, error);
+    }
+  }
+  /**
+   * Gets a default value for a column type (used when adding NOT NULL columns).
+   */
+  getDefaultValue(type) {
+    switch (type) {
+      case "text":
+      case "uuid":
+        return "DEFAULT ''";
+      case "integer":
+      case "bigint":
+      case "float":
+        return "DEFAULT 0";
+      case "boolean":
+        return "DEFAULT 0";
+      case "jsonb":
+        return "DEFAULT '{}'";
+      case "timestamp":
+        return "DEFAULT CURRENT_TIMESTAMP";
+      default:
+        return "DEFAULT ''";
+    }
+  }
+  /**
+   * Alters an existing table to add missing columns.
+   * Used for schema migrations when new columns are added.
+   *
+   * @param args - The alter table arguments
+   * @param args.tableName - The name of the table to alter
+   * @param args.schema - The full schema definition for the table
+   * @param args.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 tableInfo = await this.client.execute({
+        sql: `PRAGMA table_info("${parsedTableName}")`
       });
-      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");
+      const existingColumns = new Set((tableInfo.rows || []).map((row) => row.name?.toLowerCase()));
+      for (const columnName of ifNotExists) {
+        if (!existingColumns.has(columnName.toLowerCase()) && schema[columnName]) {
+          const columnDef = schema[columnName];
+          const sqlType = this.getSqlType(columnDef.type);
+          const defaultValue = this.getDefaultValue(columnDef.type);
+          const alterSql = `ALTER TABLE ${parsedTableName} ADD COLUMN "${columnName}" ${sqlType} ${defaultValue}`;
+          await this.client.execute(alterSql);
+          this.logger.debug(`LibSQLDB: Added column ${columnName} to table ${tableName}`);
         }
       }
-      if (threadUpdateStatement) {
-        await this.client.execute(threadUpdateStatement);
-      }
-      const list = new agent.MessageList().add(messages, "memory");
-      return { messages: list.get.all.db() };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_SAVE_MESSAGES_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "ALTER_TABLE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
         },
         error$1
       );
     }
   }
-  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(`${utils.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(`${utils.parseSqlIdentifier(dbKey, "column name")} = ?`);
-          let value = updatableFields[key];
-          if (typeof value === "object" && value !== null) {
-            value = JSON.stringify(value);
+  /**
+   * Deletes all records from the specified table.
+   * Errors are logged but not thrown.
+   *
+   * @param args - The delete arguments
+   * @param args.tableName - The name of the table to clear
+   */
+  async deleteData({ tableName }) {
+    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+    try {
+      await this.client.execute(`DELETE FROM ${parsedTableName}`);
+    } catch (e) {
+      const mastraError = new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "CLEAR_TABLE", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
           }
-          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;
+        },
+        e
+      );
+      this.logger?.trackException?.(mastraError);
+      this.logger?.error?.(mastraError.toString());
     }
-    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]
-        });
+  }
+};
+
+// src/storage/domains/agents/index.ts
+var AgentsLibSQL = class extends storage.AgentsStorage {
+  #db;
+  constructor(config) {
+    super();
+    const client = resolveClient(config);
+    this.#db = new LibSQLDB({ client, maxRetries: config.maxRetries, initialBackoffMs: config.initialBackoffMs });
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_AGENTS, schema: storage.AGENTS_SCHEMA });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: storage.TABLE_AGENTS });
+  }
+  parseJson(value, fieldName) {
+    if (!value) return void 0;
+    if (typeof value !== "string") return value;
+    try {
+      return JSON.parse(value);
+    } catch (error$1) {
+      const details = {
+        value: value.length > 100 ? value.substring(0, 100) + "..." : value
+      };
+      if (fieldName) {
+        details.field = fieldName;
       }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "PARSE_JSON", "INVALID_JSON"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: `Failed to parse JSON${fieldName ? ` for field "${fieldName}"` : ""}: ${error$1 instanceof Error ? error$1.message : "Unknown error"}`,
+          details
+        },
+        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));
   }
-  async deleteMessages(messageIds) {
-    if (!messageIds || messageIds.length === 0) {
-      return;
-    }
+  parseRow(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      instructions: row.instructions,
+      model: this.parseJson(row.model, "model"),
+      tools: this.parseJson(row.tools, "tools"),
+      defaultOptions: this.parseJson(row.defaultOptions, "defaultOptions"),
+      workflows: this.parseJson(row.workflows, "workflows"),
+      agents: this.parseJson(row.agents, "agents"),
+      inputProcessors: this.parseJson(row.inputProcessors, "inputProcessors"),
+      outputProcessors: this.parseJson(row.outputProcessors, "outputProcessors"),
+      memory: this.parseJson(row.memory, "memory"),
+      scorers: this.parseJson(row.scorers, "scorers"),
+      metadata: this.parseJson(row.metadata, "metadata"),
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    };
+  }
+  async getAgentById({ id }) {
     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;
-      }
+      const result = await this.#db.select({
+        tableName: storage.TABLE_AGENTS,
+        keys: { id }
+      });
+      return result ? this.parseRow(result) : null;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_DELETE_MESSAGES_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "GET_AGENT_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { messageIds: messageIds.join(", ") }
+          details: { agentId: id }
         },
         error$1
       );
     }
   }
-  async getResourceById({ resourceId }) {
-    const result = await this.operations.load({
-      tableName: storage.TABLE_RESOURCES,
-      keys: { id: resourceId }
-    });
-    if (!result) {
-      return null;
+  async createAgent({ agent }) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      await this.#db.insert({
+        tableName: storage.TABLE_AGENTS,
+        record: {
+          id: agent.id,
+          name: agent.name,
+          description: agent.description ?? null,
+          instructions: agent.instructions,
+          model: agent.model,
+          tools: agent.tools ?? null,
+          defaultOptions: agent.defaultOptions ?? null,
+          workflows: agent.workflows ?? null,
+          agents: agent.agents ?? null,
+          inputProcessors: agent.inputProcessors ?? null,
+          outputProcessors: agent.outputProcessors ?? null,
+          memory: agent.memory ?? null,
+          scorers: agent.scorers ?? null,
+          metadata: agent.metadata ?? null,
+          createdAt: now,
+          updatedAt: now
+        }
+      });
+      return {
+        ...agent,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "CREATE_AGENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId: agent.id }
+        },
+        error$1
+      );
     }
-    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)
+  async updateAgent({ id, ...updates }) {
+    try {
+      const existingAgent = await this.getAgentById({ id });
+      if (!existingAgent) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("LIBSQL", "UPDATE_AGENT", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: `Agent ${id} not found`,
+          details: { agentId: id }
+        });
       }
-    });
-    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(),
+      const data = {
         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;
+      if (updates.name !== void 0) data.name = updates.name;
+      if (updates.description !== void 0) data.description = updates.description;
+      if (updates.instructions !== void 0) data.instructions = updates.instructions;
+      if (updates.model !== void 0) data.model = updates.model;
+      if (updates.tools !== void 0) data.tools = updates.tools;
+      if (updates.defaultOptions !== void 0) data.defaultOptions = updates.defaultOptions;
+      if (updates.workflows !== void 0) data.workflows = updates.workflows;
+      if (updates.agents !== void 0) data.agents = updates.agents;
+      if (updates.inputProcessors !== void 0) data.inputProcessors = updates.inputProcessors;
+      if (updates.outputProcessors !== void 0) data.outputProcessors = updates.outputProcessors;
+      if (updates.memory !== void 0) data.memory = updates.memory;
+      if (updates.scorers !== void 0) data.scorers = updates.scorers;
+      if (updates.metadata !== void 0) {
+        data.metadata = { ...existingAgent.metadata, ...updates.metadata };
+      }
+      if (Object.keys(data).length > 1) {
+        await this.#db.update({
+          tableName: storage.TABLE_AGENTS,
+          keys: { id },
+          data
+        });
+      }
+      const updatedAgent = await this.getAgentById({ id });
+      if (!updatedAgent) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("LIBSQL", "UPDATE_AGENT", "NOT_FOUND_AFTER_UPDATE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: `Agent ${id} not found after update`,
+          details: { agentId: id }
+        });
+      }
+      return updatedAgent;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "UPDATE_AGENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId: id }
+        },
+        error$1
+      );
+    }
   }
-  async getThreadById({ threadId }) {
+  async deleteAgent({ id }) {
     try {
-      const result = await this.operations.load({
-        tableName: storage.TABLE_THREADS,
-        keys: { id: threadId }
+      await this.#db.delete({
+        tableName: storage.TABLE_AGENTS,
+        keys: { id }
       });
-      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",
+          id: storage.createStorageErrorId("LIBSQL", "DELETE_AGENT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: { agentId: id }
         },
         error$1
       );
     }
   }
-  async listThreadsByResourceId(args) {
-    const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
+  async listAgents(args) {
+    const { page = 0, perPage: perPageInput, orderBy } = args || {};
+    const { field, direction } = this.parseOrderBy(orderBy);
     if (page < 0) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_LIST_THREADS_BY_RESOURCE_ID_INVALID_PAGE",
+          id: storage.createStorageErrorId("LIBSQL", "LIST_AGENTS", "INVALID_PAGE"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: { page }
@@ -1462,28 +2018,11 @@ var MemoryLibSQL = class extends storage.MemoryStorage {
     }
     const perPage = storage.normalizePerPage(perPageInput, 100);
     const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-    const { field, direction } = this.parseOrderBy(orderBy);
     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 countResult = await this.client.execute({
-        sql: `SELECT COUNT(*) as count ${baseQuery}`,
-        args: queryParams
-      });
-      const total = Number(countResult.rows?.[0]?.count ?? 0);
+      const total = await this.#db.selectTotalCount({ tableName: storage.TABLE_AGENTS });
       if (total === 0) {
         return {
-          threads: [],
+          agents: [],
           total: 0,
           page,
           perPage: perPageForResponse,
@@ -1491,942 +2030,1199 @@ var MemoryLibSQL = class extends storage.MemoryStorage {
         };
       }
       const limitValue = perPageInput === false ? total : perPage;
-      const dataResult = await this.client.execute({
-        sql: `SELECT * ${baseQuery} ORDER BY "${field}" ${direction} LIMIT ? OFFSET ?`,
-        args: [...queryParams, limitValue, offset]
+      const rows = await this.#db.selectMany({
+        tableName: storage.TABLE_AGENTS,
+        orderBy: `"${field}" ${direction}`,
+        limit: limitValue,
+        offset
       });
-      const threads = (dataResult.rows || []).map(mapRowToStorageThreadType);
+      const agents = rows.map((row) => this.parseRow(row));
       return {
-        threads,
+        agents,
         total,
         page,
         perPage: perPageForResponse,
         hasMore: perPageInput === false ? false : offset + perPage < total
       };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: "LIBSQL_STORE_LIST_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: perPageForResponse,
-        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;
-    }
-  }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    const thread = await this.getThreadById({ threadId: id });
-    if (!thread) {
-      throw new error.MastraError({
-        id: "LIBSQL_STORE_UPDATE_THREAD_FAILED_THREAD_NOT_FOUND",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: `Thread ${id} not found`,
-        details: {
-          status: 404,
-          threadId: id
-        }
-      });
-    }
-    const updatedThread = {
-      ...thread,
-      title,
-      metadata: {
-        ...thread.metadata,
-        ...metadata
-      }
-    };
-    try {
-      await this.client.execute({
-        sql: `UPDATE ${storage.TABLE_THREADS} SET title = ?, metadata = ? WHERE id = ?`,
-        args: [title, JSON.stringify(updatedThread.metadata), id]
-      });
-      return updatedThread;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "LIBSQL_STORE_UPDATE_THREAD_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to update thread ${id}`,
-          details: { threadId: id }
-        },
-        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",
+          id: storage.createStorageErrorId("LIBSQL", "LIST_AGENTS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         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` || v === null) {
-      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
-  };
-}
-function prepareUpdateStatement({
-  tableName,
-  updates,
-  keys
-}) {
-  const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
-  const schema = storage.TABLE_SCHEMAS[tableName];
-  const updateColumns = Object.keys(updates).map((col) => utils.parseSqlIdentifier(col, "column name"));
-  const updateValues = Object.values(updates).map(transformToSqlValue);
-  const setClause = updateColumns.map((col) => `${col} = ?`).join(", ");
-  const whereClause = prepareWhereClause(keys, schema);
-  return {
-    sql: `UPDATE ${parsedTableName} SET ${setClause}${whereClause.sql}`,
-    args: [...updateValues, ...whereClause.args]
-  };
-}
-function transformToSqlValue(value) {
-  if (typeof value === "undefined" || value === null) {
-    return null;
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  return typeof value === "object" ? JSON.stringify(value) : value;
-}
-function prepareDeleteStatement({ tableName, keys }) {
-  const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
-  const whereClause = prepareWhereClause(keys, storage.TABLE_SCHEMAS[tableName]);
-  return {
-    sql: `DELETE FROM ${parsedTableName}${whereClause.sql}`,
-    args: whereClause.args
-  };
-}
-function prepareWhereClause(filters, schema) {
-  const conditions = [];
-  const args = [];
-  for (const [columnName, filterValue] of Object.entries(filters)) {
-    const column = schema[columnName];
-    if (!column) {
-      throw new Error(`Unknown column: ${columnName}`);
-    }
-    const parsedColumn = utils.parseSqlIdentifier(columnName, "column name");
-    const result = buildCondition2(parsedColumn, filterValue);
-    conditions.push(result.condition);
-    args.push(...result.args);
-  }
-  return {
-    sql: conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "",
-    args
-  };
-}
-function buildCondition2(columnName, filterValue) {
-  if (filterValue === null) {
-    return { condition: `${columnName} IS NULL`, args: [] };
-  }
-  if (typeof filterValue === "object" && filterValue !== null && ("startAt" in filterValue || "endAt" in filterValue)) {
-    return buildDateRangeCondition(columnName, filterValue);
-  }
-  return {
-    condition: `${columnName} = ?`,
-    args: [transformToSqlValue(filterValue)]
-  };
-}
-function buildDateRangeCondition(columnName, range) {
-  const conditions = [];
-  const args = [];
-  if (range.startAt !== void 0) {
-    conditions.push(`${columnName} >= ?`);
-    args.push(transformToSqlValue(range.startAt));
-  }
-  if (range.endAt !== void 0) {
-    conditions.push(`${columnName} <= ?`);
-    args.push(transformToSqlValue(range.endAt));
-  }
-  if (conditions.length === 0) {
-    throw new Error("Date range must specify at least startAt or endAt");
-  }
-  return {
-    condition: conditions.join(" AND "),
-    args
-  };
-}
-function buildDateRangeFilter(dateRange, columnName = "createdAt") {
-  if (!dateRange?.start && !dateRange?.end) {
-    return {};
-  }
-  const filter = {};
-  if (dateRange.start) {
-    filter.startAt = new Date(dateRange.start).toISOString();
+};
+var MemoryLibSQL = class extends storage.MemoryStorage {
+  #client;
+  #db;
+  constructor(config) {
+    super();
+    const client = resolveClient(config);
+    this.#client = client;
+    this.#db = new LibSQLDB({ client, maxRetries: config.maxRetries, initialBackoffMs: config.initialBackoffMs });
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_THREADS, schema: storage.TABLE_SCHEMAS[storage.TABLE_THREADS] });
+    await this.#db.createTable({ tableName: storage.TABLE_MESSAGES, schema: storage.TABLE_SCHEMAS[storage.TABLE_MESSAGES] });
+    await this.#db.createTable({ tableName: storage.TABLE_RESOURCES, schema: storage.TABLE_SCHEMAS[storage.TABLE_RESOURCES] });
+    await this.#db.alterTable({
+      tableName: storage.TABLE_MESSAGES,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_MESSAGES],
+      ifNotExists: ["resourceId"]
+    });
   }
-  if (dateRange.end) {
-    filter.endAt = new Date(dateRange.end).toISOString();
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: storage.TABLE_MESSAGES });
+    await this.#db.deleteData({ tableName: storage.TABLE_THREADS });
+    await this.#db.deleteData({ tableName: storage.TABLE_RESOURCES });
   }
-  return { [columnName]: filter };
-}
-function transformFromSqlRow({
-  tableName,
-  sqlRow
-}) {
-  const result = {};
-  const jsonColumns = new Set(
-    Object.keys(storage.TABLE_SCHEMAS[tableName]).filter((key) => storage.TABLE_SCHEMAS[tableName][key].type === "jsonb").map((key) => key)
-  );
-  const dateColumns = new Set(
-    Object.keys(storage.TABLE_SCHEMAS[tableName]).filter((key) => storage.TABLE_SCHEMAS[tableName][key].type === "timestamp").map((key) => key)
-  );
-  for (const [key, value] of Object.entries(sqlRow)) {
-    if (value === null || value === void 0) {
-      result[key] = value;
-      continue;
-    }
-    if (dateColumns.has(key) && typeof value === "string") {
-      result[key] = new Date(value);
-      continue;
-    }
-    if (jsonColumns.has(key) && typeof value === "string") {
-      result[key] = storage.safelyParseJSON(value);
-      continue;
+  parseRow(row) {
+    let content = row.content;
+    try {
+      content = JSON.parse(row.content);
+    } catch {
     }
-    result[key] = value;
+    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;
   }
-  return result;
-}
-
-// src/storage/domains/observability/index.ts
-var ObservabilityLibSQL = class extends storage.ObservabilityStorage {
-  operations;
-  constructor({ operations }) {
-    super();
-    this.operations = operations;
+  async _getIncludedMessages({ include }) {
+    if (!include || include.length === 0) return null;
+    const unionQueries = [];
+    const params = [];
+    for (const inc of include) {
+      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+      unionQueries.push(
+        `
+                SELECT * FROM (
+                  WITH target_thread AS (
+                    SELECT thread_id FROM "${storage.TABLE_MESSAGES}" WHERE id = ?
+                  ),
+                  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 = (SELECT thread_id FROM target_thread)
+                  ),
+                  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(id, 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 createSpan(span) {
+  async listMessagesById({ messageIds }) {
+    if (messageIds.length === 0) return { messages: [] };
     try {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const record = {
-        ...span,
-        createdAt: now,
-        updatedAt: now
-      };
-      return this.operations.insert({ tableName: storage.TABLE_SPANS, record });
+      const sql = `
+        SELECT 
+          id, 
+          content, 
+          role, 
+          type,
+          "createdAt", 
+          thread_id,
+          "resourceId"
+        FROM "${storage.TABLE_MESSAGES}"
+        WHERE id IN (${messageIds.map(() => "?").join(", ")})
+        ORDER BY "createdAt" DESC
+      `;
+      const result = await this.#client.execute({ sql, args: messageIds });
+      if (!result.rows) return { messages: [] };
+      const list = new agent.MessageList().add(result.rows.map(this.parseRow), "memory");
+      return { messages: list.get.all.db() };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_CREATE_SPAN_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "LIST_MESSAGES_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { messageIds: JSON.stringify(messageIds) }
+        },
+        error$1
+      );
+    }
+  }
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    const threadIds = Array.isArray(threadId) ? threadId : [threadId];
+    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "LIST_MESSAGES", "INVALID_THREAD_ID"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId: Array.isArray(threadId) ? threadId.join(",") : threadId }
+        },
+        new Error("threadId must be a non-empty string or array of non-empty strings")
+      );
+    }
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "LIST_MESSAGES", "INVALID_PAGE"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+      const orderByStatement = `ORDER BY "${field}" ${direction}`;
+      const threadPlaceholders = threadIds.map(() => "?").join(", ");
+      const conditions = [`thread_id IN (${threadPlaceholders})`];
+      const queryParams = [...threadIds];
+      if (resourceId) {
+        conditions.push(`"resourceId" = ?`);
+        queryParams.push(resourceId);
+      }
+      if (filter?.dateRange?.start) {
+        conditions.push(`"createdAt" >= ?`);
+        queryParams.push(
+          filter.dateRange.start instanceof Date ? filter.dateRange.start.toISOString() : filter.dateRange.start
+        );
+      }
+      if (filter?.dateRange?.end) {
+        conditions.push(`"createdAt" <= ?`);
+        queryParams.push(
+          filter.dateRange.end instanceof Date ? filter.dateRange.end.toISOString() : filter.dateRange.end
+        );
+      }
+      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);
+      const limitValue = perPageInput === false ? total : perPage;
+      const dataResult = await this.#client.execute({
+        sql: `SELECT id, content, role, type, "createdAt", "resourceId", "thread_id" FROM ${storage.TABLE_MESSAGES} ${whereClause} ${orderByStatement} LIMIT ? OFFSET ?`,
+        args: [...queryParams, limitValue, offset]
+      });
+      const messages = (dataResult.rows || []).map((row) => this.parseRow(row));
+      if (total === 0 && messages.length === 0 && (!include || include.length === 0)) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const messageIds = new Set(messages.map((m) => m.id));
+      if (include && include.length > 0) {
+        const includeMessages = await this._getIncludedMessages({ include });
+        if (includeMessages) {
+          for (const includeMsg of includeMessages) {
+            if (!messageIds.has(includeMsg.id)) {
+              messages.push(includeMsg);
+              messageIds.add(includeMsg.id);
+            }
+          }
+        }
+      }
+      const list = new agent.MessageList().add(messages, "memory");
+      let finalMessages = list.get.all.db();
+      finalMessages = finalMessages.sort((a, b) => {
+        const isDateField = field === "createdAt" || field === "updatedAt";
+        const aValue = isDateField ? new Date(a[field]).getTime() : a[field];
+        const bValue = isDateField ? new Date(b[field]).getTime() : b[field];
+        if (typeof aValue === "number" && typeof bValue === "number") {
+          return direction === "ASC" ? aValue - bValue : bValue - aValue;
+        }
+        return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
+      });
+      const threadIdSet = new Set(threadIds);
+      const returnedThreadMessageIds = new Set(
+        finalMessages.filter((m) => m.threadId && threadIdSet.has(m.threadId)).map((m) => m.id)
+      );
+      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
+      const hasMore = perPageInput !== false && !allThreadMessagesReturned && offset + perPage < total;
+      return {
+        messages: finalMessages,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore
+      };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "LIST_MESSAGES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            spanId: span.spanId,
-            traceId: span.traceId,
-            spanType: span.spanType,
-            spanName: span.name
+            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
+            resourceId: resourceId ?? ""
           }
         },
         error$1
       );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
     }
   }
-  async getTrace(traceId) {
+  async saveMessages({ messages }) {
+    if (messages.length === 0) return { messages };
     try {
-      const spans = await this.operations.loadMany({
-        tableName: storage.TABLE_SPANS,
-        whereClause: { sql: " WHERE traceId = ?", args: [traceId] },
-        orderBy: "startedAt DESC"
+      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
+          ]
+        };
       });
-      if (!spans || spans.length === 0) {
-        return null;
+      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");
+        }
       }
-      return {
-        traceId,
-        spans: spans.map((span) => transformFromSqlRow({ tableName: storage.TABLE_SPANS, sqlRow: span }))
-      };
+      if (threadUpdateStatement) {
+        await this.#client.execute(threadUpdateStatement);
+      }
+      const list = new agent.MessageList().add(messages, "memory");
+      return { messages: list.get.all.db() };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_GET_TRACE_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "SAVE_MESSAGES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: {
-            traceId
-          }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
-  async updateSpan({
-    spanId,
-    traceId,
-    updates
+  async updateMessages({
+    messages
   }) {
-    try {
-      await this.operations.update({
-        tableName: storage.TABLE_SPANS,
-        keys: { spanId, traceId },
-        data: { ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
-      });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "LIBSQL_STORE_UPDATE_SPAN_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: {
-            spanId,
-            traceId
-          }
-        },
-        error$1
-      );
+    if (messages.length === 0) {
+      return [];
     }
-  }
-  async getTracesPaginated({
-    filters,
-    pagination
-  }) {
-    const page = pagination?.page ?? 0;
-    const perPage = pagination?.perPage ?? 10;
-    const { entityId, entityType, ...actualFilters } = filters || {};
-    const filtersWithDateRange = {
-      ...actualFilters,
-      ...buildDateRangeFilter(pagination?.dateRange, "startedAt"),
-      parentSpanId: null
+    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"
     };
-    const whereClause = prepareWhereClause(filtersWithDateRange, storage.SPAN_SCHEMA);
-    let actualWhereClause = whereClause.sql || "";
-    if (entityId && entityType) {
-      const statement = `name = ?`;
-      let name = "";
-      if (entityType === "workflow") {
-        name = `workflow run: '${entityId}'`;
-      } else if (entityType === "agent") {
-        name = `agent run: '${entityId}'`;
-      } else {
-        const error$1 = new error.MastraError({
-          id: "LIBSQL_STORE_GET_TRACES_PAGINATED_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: {
-            entityType
-          },
-          text: `Cannot filter by entity type: ${entityType}`
-        });
-        this.logger?.trackException(error$1);
-        throw error$1;
+    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);
       }
-      whereClause.args.push(name);
-      if (actualWhereClause) {
-        actualWhereClause += ` AND ${statement}`;
-      } else {
-        actualWhereClause += `WHERE ${statement}`;
+      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;
+      }
+      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 (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]
+        });
       }
     }
-    const orderBy = "startedAt DESC";
-    let count = 0;
+    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 {
-      count = await this.operations.loadTotalCount({
-        tableName: storage.TABLE_SPANS,
-        whereClause: { sql: actualWhereClause, args: whereClause.args }
-      });
+      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_GET_TRACES_PAGINATED_COUNT_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "DELETE_MESSAGES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { messageIds: messageIds.join(", ") }
         },
         error$1
       );
     }
-    if (count === 0) {
-      return {
-        pagination: {
-          total: 0,
-          page,
-          perPage,
-          hasMore: false
-        },
-        spans: []
+  }
+  async getResourceById({ resourceId }) {
+    const result = await this.#db.select({
+      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.#db.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 });
     }
-    try {
-      const spans = await this.operations.loadMany({
-        tableName: storage.TABLE_SPANS,
-        whereClause: {
-          sql: actualWhereClause,
-          args: whereClause.args
-        },
-        orderBy,
-        offset: page * perPage,
-        limit: perPage
+    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.#db.select({
+        tableName: storage.TABLE_THREADS,
+        keys: { id: threadId }
       });
+      if (!result) {
+        return null;
+      }
       return {
-        pagination: {
-          total: count,
-          page,
-          perPage,
-          hasMore: spans.length === perPage
-        },
-        spans: spans.map((span) => transformFromSqlRow({ tableName: storage.TABLE_SPANS, sqlRow: span }))
+        ...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_TRACES_PAGINATED_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "GET_THREAD_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
         },
         error$1
       );
     }
   }
-  async batchCreateSpans(args) {
-    try {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      return this.operations.batchInsert({
-        tableName: storage.TABLE_SPANS,
-        records: args.records.map((record) => ({
-          ...record,
-          createdAt: now,
-          updatedAt: now
-        }))
-      });
-    } catch (error$1) {
+  async listThreadsByResourceId(args) {
+    const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
+    if (page < 0) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_BATCH_CREATE_SPANS_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "LIST_THREADS_BY_RESOURCE_ID", "INVALID_PAGE"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER
+          category: error.ErrorCategory.USER,
+          details: { page }
         },
-        error$1
+        new Error("page must be >= 0")
       );
     }
-  }
-  async batchUpdateSpans(args) {
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    const { field, direction } = this.parseOrderBy(orderBy);
     try {
-      return this.operations.batchUpdate({
-        tableName: storage.TABLE_SPANS,
-        updates: args.records.map((record) => ({
-          keys: { spanId: record.spanId, traceId: record.traceId },
-          data: { ...record.updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
-        }))
+      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 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: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const dataResult = await this.#client.execute({
+        sql: `SELECT * ${baseQuery} ORDER BY "${field}" ${direction} LIMIT ? OFFSET ?`,
+        args: [...queryParams, limitValue, offset]
       });
+      const threads = (dataResult.rows || []).map(mapRowToStorageThreadType);
+      return {
+        threads,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "LIBSQL_STORE_BATCH_UPDATE_SPANS_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "LIST_THREADS_BY_RESOURCE_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
         },
         error$1
       );
+      this.logger?.trackException?.(mastraError);
+      this.logger?.error?.(mastraError.toString());
+      return {
+        threads: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
     }
   }
-  async batchDeleteTraces(args) {
+  async saveThread({ thread }) {
     try {
-      const keys = args.traceIds.map((traceId) => ({ traceId }));
-      return this.operations.batchDelete({
-        tableName: storage.TABLE_SPANS,
-        keys
+      await this.#db.insert({
+        tableName: storage.TABLE_THREADS,
+        record: {
+          ...thread,
+          metadata: JSON.stringify(thread.metadata)
+        }
       });
+      return thread;
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "LIBSQL_STORE_BATCH_DELETE_TRACES_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "SAVE_THREAD", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId: thread.id }
         },
         error$1
       );
+      this.logger?.trackException?.(mastraError);
+      this.logger?.error?.(mastraError.toString());
+      throw mastraError;
     }
   }
-};
-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;
-    }
-    if (tableName === storage.TABLE_SPANS) {
-      const stmnt = `CREATE TABLE IF NOT EXISTS ${parsedTableName} (
-                    ${columns.join(",\n")},
-                    PRIMARY KEY (traceId, spanId)
-                )`;
-      return stmnt;
-    }
-    return `CREATE TABLE IF NOT EXISTS ${parsedTableName} (${columns.join(", ")})`;
-  }
-  async createTable({
-    tableName,
-    schema
+  async updateThread({
+    id,
+    title,
+    metadata
   }) {
+    const thread = await this.getThreadById({ threadId: id });
+    if (!thread) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("LIBSQL", "UPDATE_THREAD", "NOT_FOUND"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: `Thread ${id} not found`,
+        details: {
+          status: 404,
+          threadId: id
+        }
+      });
+    }
+    const updatedThread = {
+      ...thread,
+      title,
+      metadata: {
+        ...thread.metadata,
+        ...metadata
+      }
+    };
     try {
-      this.logger.debug(`Creating database table`, { tableName, operation: "schema init" });
-      const sql = this.getCreateTableSQL(tableName, schema);
-      await this.client.execute(sql);
+      await this.#client.execute({
+        sql: `UPDATE ${storage.TABLE_THREADS} SET title = ?, metadata = ? WHERE id = ?`,
+        args: [title, JSON.stringify(updatedThread.metadata), id]
+      });
+      return updatedThread;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_CREATE_TABLE_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "UPDATE_THREAD", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
+          text: `Failed to update thread ${id}`,
+          details: { threadId: id }
         },
         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 loadMany({
-    tableName,
-    whereClause,
-    orderBy,
-    offset,
-    limit,
-    args
-  }) {
-    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
-    let statement = `SELECT * FROM ${parsedTableName}`;
-    if (whereClause?.sql) {
-      statement += `${whereClause.sql}`;
-    }
-    if (orderBy) {
-      statement += ` ORDER BY ${orderBy}`;
-    }
-    if (limit) {
-      statement += ` LIMIT ${limit}`;
-    }
-    if (offset) {
-      statement += ` OFFSET ${offset}`;
+  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: storage.createStorageErrorId("LIBSQL", "DELETE_THREAD", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error$1
+      );
     }
-    const result = await this.client.execute({
-      sql: statement,
-      args: [...whereClause?.args ?? [], ...args ?? []]
-    });
-    return result.rows;
   }
-  async loadTotalCount({
-    tableName,
-    whereClause
-  }) {
-    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
-    const statement = `SELECT COUNT(*) as count FROM ${parsedTableName} ${whereClause ? `${whereClause.sql}` : ""}`;
-    const result = await this.client.execute({
-      sql: statement,
-      args: whereClause?.args ?? []
-    });
-    if (!result.rows || result.rows.length === 0) {
-      return 0;
-    }
-    return result.rows[0]?.count ?? 0;
+};
+var ObservabilityLibSQL = class extends storage.ObservabilityStorage {
+  #db;
+  constructor(config) {
+    super();
+    const client = resolveClient(config);
+    this.#db = new LibSQLDB({ client, maxRetries: config.maxRetries, initialBackoffMs: config.initialBackoffMs });
   }
-  update(args) {
-    const executeWriteOperationWithRetry = createExecuteWriteOperationWithRetry({
-      logger: this.logger,
-      maxRetries: this.maxRetries,
-      initialBackoffMs: this.initialBackoffMs
-    });
-    return executeWriteOperationWithRetry(() => this.executeUpdate(args), `update table ${args.tableName}`);
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_SPANS, schema: storage.SPAN_SCHEMA });
   }
-  async executeUpdate({
-    tableName,
-    keys,
-    data
-  }) {
-    await this.client.execute(prepareUpdateStatement({ tableName, updates: data, keys }));
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: storage.TABLE_SPANS });
   }
-  async doBatchInsert({
-    tableName,
-    records
-  }) {
-    if (records.length === 0) return;
-    const batchStatements = records.map((r) => prepareStatement({ tableName, record: r }));
-    await this.client.batch(batchStatements, "write");
+  get tracingStrategy() {
+    return {
+      preferred: "batch-with-updates",
+      supported: ["batch-with-updates", "insert-only"]
+    };
   }
-  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) => {
+  async createSpan(args) {
+    const { span } = args;
+    try {
+      const startedAt = span.startedAt instanceof Date ? span.startedAt.toISOString() : span.startedAt;
+      const endedAt = span.endedAt instanceof Date ? span.endedAt.toISOString() : span.endedAt;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const record = {
+        ...span,
+        startedAt,
+        endedAt,
+        createdAt: now,
+        updatedAt: now
+      };
+      return this.#db.insert({ tableName: storage.TABLE_SPANS, record });
+    } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_BATCH_INSERT_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "CREATE_SPAN", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
+          category: error.ErrorCategory.USER,
           details: {
-            tableName: args.tableName
+            spanId: span.spanId,
+            traceId: span.traceId,
+            spanType: span.spanType,
+            name: span.name
           }
         },
         error$1
       );
-    });
+    }
   }
-  /**
-   * Public batch update method with retry logic
-   */
-  batchUpdate(args) {
-    const executeWriteOperationWithRetry = createExecuteWriteOperationWithRetry({
-      logger: this.logger,
-      maxRetries: this.maxRetries,
-      initialBackoffMs: this.initialBackoffMs
-    });
-    return executeWriteOperationWithRetry(
-      () => this.executeBatchUpdate(args),
-      `batch update in table ${args.tableName}`
-    ).catch((error$1) => {
+  async getSpan(args) {
+    const { traceId, spanId } = args;
+    try {
+      const rows = await this.#db.selectMany({
+        tableName: storage.TABLE_SPANS,
+        whereClause: { sql: " WHERE traceId = ? AND spanId = ?", args: [traceId, spanId] },
+        limit: 1
+      });
+      if (!rows || rows.length === 0) {
+        return null;
+      }
+      return {
+        span: transformFromSqlRow({ tableName: storage.TABLE_SPANS, sqlRow: rows[0] })
+      };
+    } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_BATCH_UPDATE_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "GET_SPAN", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName: args.tableName
-          }
+          category: error.ErrorCategory.USER,
+          details: { traceId, spanId }
         },
         error$1
       );
-    });
+    }
   }
-  /**
-   * Updates multiple records in batch. Each record can be updated based on single or composite keys.
-   */
-  async executeBatchUpdate({
-    tableName,
-    updates
-  }) {
-    if (updates.length === 0) return;
-    const batchStatements = updates.map(
-      ({ keys, data }) => prepareUpdateStatement({
-        tableName,
-        updates: data,
-        keys
-      })
-    );
-    await this.client.batch(batchStatements, "write");
+  async getRootSpan(args) {
+    const { traceId } = args;
+    try {
+      const rows = await this.#db.selectMany({
+        tableName: storage.TABLE_SPANS,
+        whereClause: { sql: " WHERE traceId = ? AND parentSpanId IS NULL", args: [traceId] },
+        limit: 1
+      });
+      if (!rows || rows.length === 0) {
+        return null;
+      }
+      return {
+        span: transformFromSqlRow({ tableName: storage.TABLE_SPANS, sqlRow: rows[0] })
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "GET_ROOT_SPAN", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { traceId }
+        },
+        error$1
+      );
+    }
   }
-  /**
-   * Public batch delete method with retry logic
-   */
-  batchDelete({ tableName, keys }) {
-    const executeWriteOperationWithRetry = createExecuteWriteOperationWithRetry({
-      logger: this.logger,
-      maxRetries: this.maxRetries,
-      initialBackoffMs: this.initialBackoffMs
-    });
-    return executeWriteOperationWithRetry(
-      () => this.executeBatchDelete({ tableName, keys }),
-      `batch delete from table ${tableName}`
-    ).catch((error$1) => {
+  async getTrace(args) {
+    const { traceId } = args;
+    try {
+      const spans = await this.#db.selectMany({
+        tableName: storage.TABLE_SPANS,
+        whereClause: { sql: " WHERE traceId = ?", args: [traceId] },
+        orderBy: "startedAt ASC"
+      });
+      if (!spans || spans.length === 0) {
+        return null;
+      }
+      return {
+        traceId,
+        spans: spans.map((span) => transformFromSqlRow({ tableName: storage.TABLE_SPANS, sqlRow: span }))
+      };
+    } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_BATCH_DELETE_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "GET_TRACE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
+          category: error.ErrorCategory.USER,
           details: {
-            tableName
+            traceId
           }
         },
         error$1
       );
-    });
+    }
   }
-  /**
-   * Deletes multiple records in batch. Each record can be deleted based on single or composite keys.
-   */
-  async executeBatchDelete({
-    tableName,
-    keys
-  }) {
-    if (keys.length === 0) return;
-    const batchStatements = keys.map(
-      (keyObj) => prepareDeleteStatement({
-        tableName,
-        keys: keyObj
-      })
-    );
-    await this.client.batch(batchStatements, "write");
+  async updateSpan(args) {
+    const { traceId, spanId, updates } = args;
+    try {
+      const data = { ...updates };
+      if (data.endedAt instanceof Date) {
+        data.endedAt = data.endedAt.toISOString();
+      }
+      if (data.startedAt instanceof Date) {
+        data.startedAt = data.startedAt.toISOString();
+      }
+      data.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.#db.update({
+        tableName: storage.TABLE_SPANS,
+        keys: { spanId, traceId },
+        data
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "UPDATE_SPAN", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            spanId,
+            traceId
+          }
+        },
+        error$1
+      );
+    }
   }
-  /**
-   * 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");
+  async listTraces(args) {
+    const { filters, pagination, orderBy } = storage.listTracesArgsSchema.parse(args);
+    const { page, perPage } = pagination;
+    const tableName = utils.parseSqlIdentifier(storage.TABLE_SPANS, "table name");
     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 conditions = ["parentSpanId IS NULL"];
+      const queryArgs = [];
+      if (filters) {
+        if (filters.startedAt?.start) {
+          conditions.push(`startedAt >= ?`);
+          queryArgs.push(filters.startedAt.start.toISOString());
         }
+        if (filters.startedAt?.end) {
+          conditions.push(`startedAt <= ?`);
+          queryArgs.push(filters.startedAt.end.toISOString());
+        }
+        if (filters.endedAt?.start) {
+          conditions.push(`endedAt >= ?`);
+          queryArgs.push(filters.endedAt.start.toISOString());
+        }
+        if (filters.endedAt?.end) {
+          conditions.push(`endedAt <= ?`);
+          queryArgs.push(filters.endedAt.end.toISOString());
+        }
+        if (filters.spanType !== void 0) {
+          conditions.push(`spanType = ?`);
+          queryArgs.push(filters.spanType);
+        }
+        if (filters.entityType !== void 0) {
+          conditions.push(`entityType = ?`);
+          queryArgs.push(filters.entityType);
+        }
+        if (filters.entityId !== void 0) {
+          conditions.push(`entityId = ?`);
+          queryArgs.push(filters.entityId);
+        }
+        if (filters.entityName !== void 0) {
+          conditions.push(`entityName = ?`);
+          queryArgs.push(filters.entityName);
+        }
+        if (filters.userId !== void 0) {
+          conditions.push(`userId = ?`);
+          queryArgs.push(filters.userId);
+        }
+        if (filters.organizationId !== void 0) {
+          conditions.push(`organizationId = ?`);
+          queryArgs.push(filters.organizationId);
+        }
+        if (filters.resourceId !== void 0) {
+          conditions.push(`resourceId = ?`);
+          queryArgs.push(filters.resourceId);
+        }
+        if (filters.runId !== void 0) {
+          conditions.push(`runId = ?`);
+          queryArgs.push(filters.runId);
+        }
+        if (filters.sessionId !== void 0) {
+          conditions.push(`sessionId = ?`);
+          queryArgs.push(filters.sessionId);
+        }
+        if (filters.threadId !== void 0) {
+          conditions.push(`threadId = ?`);
+          queryArgs.push(filters.threadId);
+        }
+        if (filters.requestId !== void 0) {
+          conditions.push(`requestId = ?`);
+          queryArgs.push(filters.requestId);
+        }
+        if (filters.environment !== void 0) {
+          conditions.push(`environment = ?`);
+          queryArgs.push(filters.environment);
+        }
+        if (filters.source !== void 0) {
+          conditions.push(`source = ?`);
+          queryArgs.push(filters.source);
+        }
+        if (filters.serviceName !== void 0) {
+          conditions.push(`serviceName = ?`);
+          queryArgs.push(filters.serviceName);
+        }
+        if (filters.scope != null) {
+          for (const [key, value] of Object.entries(filters.scope)) {
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
+              throw new error.MastraError({
+                id: storage.createStorageErrorId("LIBSQL", "LIST_TRACES", "INVALID_FILTER_KEY"),
+                domain: error.ErrorDomain.STORAGE,
+                category: error.ErrorCategory.USER,
+                details: { key }
+              });
+            }
+            conditions.push(`json_extract(scope, '$.${key}') = ?`);
+            queryArgs.push(typeof value === "string" ? value : JSON.stringify(value));
+          }
+        }
+        if (filters.metadata != null) {
+          for (const [key, value] of Object.entries(filters.metadata)) {
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
+              throw new error.MastraError({
+                id: storage.createStorageErrorId("LIBSQL", "LIST_TRACES", "INVALID_FILTER_KEY"),
+                domain: error.ErrorDomain.STORAGE,
+                category: error.ErrorCategory.USER,
+                details: { key }
+              });
+            }
+            conditions.push(`json_extract(metadata, '$.${key}') = ?`);
+            queryArgs.push(typeof value === "string" ? value : JSON.stringify(value));
+          }
+        }
+        if (filters.tags != null && filters.tags.length > 0) {
+          for (const tag of filters.tags) {
+            conditions.push(`EXISTS (SELECT 1 FROM json_each(${tableName}.tags) WHERE value = ?)`);
+            queryArgs.push(tag);
+          }
+        }
+        if (filters.status !== void 0) {
+          switch (filters.status) {
+            case storage.TraceStatus.ERROR:
+              conditions.push(`error IS NOT NULL`);
+              break;
+            case storage.TraceStatus.RUNNING:
+              conditions.push(`endedAt IS NULL AND error IS NULL`);
+              break;
+            case storage.TraceStatus.SUCCESS:
+              conditions.push(`endedAt IS NOT NULL AND error IS NULL`);
+              break;
+          }
+        }
+        if (filters.hasChildError !== void 0) {
+          if (filters.hasChildError) {
+            conditions.push(`EXISTS (
+              SELECT 1 FROM ${tableName} c
+              WHERE c.traceId = ${tableName}.traceId AND c.error IS NOT NULL
+            )`);
+          } else {
+            conditions.push(`NOT EXISTS (
+              SELECT 1 FROM ${tableName} c
+              WHERE c.traceId = ${tableName}.traceId AND c.error IS NOT NULL
+            )`);
+          }
+        }
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const sortField = orderBy.field;
+      const sortDirection = orderBy.direction;
+      let orderByClause;
+      if (sortField === "endedAt") {
+        orderByClause = sortDirection === "DESC" ? `CASE WHEN ${sortField} IS NULL THEN 0 ELSE 1 END, ${sortField} DESC` : `CASE WHEN ${sortField} IS NULL THEN 1 ELSE 0 END, ${sortField} ASC`;
+      } else {
+        orderByClause = `${sortField} ${sortDirection}`;
       }
+      const count = await this.#db.selectTotalCount({
+        tableName: storage.TABLE_SPANS,
+        whereClause: { sql: whereClause, args: queryArgs }
+      });
+      if (count === 0) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage,
+            hasMore: false
+          },
+          spans: []
+        };
+      }
+      const spans = await this.#db.selectMany({
+        tableName: storage.TABLE_SPANS,
+        whereClause: { sql: whereClause, args: queryArgs },
+        orderBy: orderByClause,
+        offset: page * perPage,
+        limit: perPage
+      });
+      return {
+        pagination: {
+          total: count,
+          page,
+          perPage,
+          hasMore: (page + 1) * perPage < count
+        },
+        spans: spans.map((span) => transformFromSqlRow({ tableName: storage.TABLE_SPANS, sqlRow: span }))
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("LIBSQL", "LIST_TRACES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        error$1
+      );
+    }
+  }
+  async batchCreateSpans(args) {
+    try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const records = args.records.map((record) => {
+        const startedAt = record.startedAt instanceof Date ? record.startedAt.toISOString() : record.startedAt;
+        const endedAt = record.endedAt instanceof Date ? record.endedAt.toISOString() : record.endedAt;
+        return {
+          ...record,
+          startedAt,
+          endedAt,
+          createdAt: now,
+          updatedAt: now
+        };
+      });
+      return this.#db.batchInsert({
+        tableName: storage.TABLE_SPANS,
+        records
+      });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_ALTER_TABLE_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "BATCH_CREATE_SPANS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
+          category: error.ErrorCategory.USER
         },
         error$1
       );
     }
   }
-  async clearTable({ tableName }) {
-    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+  async batchUpdateSpans(args) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
     try {
-      await this.client.execute(`DELETE FROM ${parsedTableName}`);
-    } catch (e) {
-      const mastraError = new error.MastraError(
+      return this.#db.batchUpdate({
+        tableName: storage.TABLE_SPANS,
+        updates: args.records.map((record) => {
+          const data = { ...record.updates };
+          if (data.endedAt instanceof Date) {
+            data.endedAt = data.endedAt.toISOString();
+          }
+          if (data.startedAt instanceof Date) {
+            data.startedAt = data.startedAt.toISOString();
+          }
+          data.updatedAt = now;
+          return {
+            keys: { spanId: record.spanId, traceId: record.traceId },
+            data
+          };
+        })
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_CLEAR_TABLE_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "BATCH_UPDATE_SPANS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
+          category: error.ErrorCategory.USER
         },
-        e
+        error$1
       );
-      this.logger?.trackException?.(mastraError);
-      this.logger?.error?.(mastraError.toString());
     }
   }
-  async dropTable({ tableName }) {
-    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+  async batchDeleteTraces(args) {
     try {
-      await this.client.execute(`DROP TABLE IF EXISTS ${parsedTableName}`);
-    } catch (e) {
+      const keys = args.traceIds.map((traceId) => ({ traceId }));
+      return this.#db.batchDelete({
+        tableName: storage.TABLE_SPANS,
+        keys
+      });
+    } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_DROP_TABLE_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "BATCH_DELETE_TRACES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
+          category: error.ErrorCategory.USER
         },
-        e
+        error$1
       );
     }
   }
 };
 var ScoresLibSQL = class extends storage.ScoresStorage {
-  operations;
-  client;
-  constructor({ client, operations }) {
+  #db;
+  #client;
+  constructor(config) {
     super();
-    this.operations = operations;
-    this.client = client;
+    const client = resolveClient(config);
+    this.#client = client;
+    this.#db = new LibSQLDB({ client, maxRetries: config.maxRetries, initialBackoffMs: config.initialBackoffMs });
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_SCORERS, schema: storage.SCORERS_SCHEMA });
+    await this.#db.alterTable({
+      tableName: storage.TABLE_SCORERS,
+      schema: storage.SCORERS_SCHEMA,
+      ifNotExists: ["spanId", "requestContext"]
+    });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: storage.TABLE_SCORERS });
   }
   async listScoresByRunId({
     runId,
@@ -2434,7 +3230,7 @@ var ScoresLibSQL = class extends storage.ScoresStorage {
   }) {
     try {
       const { page, perPage: perPageInput } = pagination;
-      const countResult = await this.client.execute({
+      const countResult = await this.#client.execute({
         sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_SCORERS} WHERE runId = ?`,
         args: [runId]
       });
@@ -2454,7 +3250,7 @@ var ScoresLibSQL = class extends storage.ScoresStorage {
       const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       const limitValue = perPageInput === false ? total : perPage;
       const end = perPageInput === false ? total : start + perPage;
-      const result = await this.client.execute({
+      const result = await this.#client.execute({
         sql: `SELECT * FROM ${storage.TABLE_SCORERS} WHERE runId = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
         args: [runId, limitValue, start]
       });
@@ -2471,7 +3267,7 @@ var ScoresLibSQL = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_GET_SCORES_BY_RUN_ID_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "LIST_SCORES_BY_RUN_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -2507,7 +3303,7 @@ var ScoresLibSQL = class extends storage.ScoresStorage {
         queryParams.push(source);
       }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-      const countResult = await this.client.execute({
+      const countResult = await this.#client.execute({
         sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_SCORERS} ${whereClause}`,
         args: queryParams
       });
@@ -2527,7 +3323,7 @@ var ScoresLibSQL = class extends storage.ScoresStorage {
       const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       const limitValue = perPageInput === false ? total : perPage;
       const end = perPageInput === false ? total : start + perPage;
-      const result = await this.client.execute({
+      const result = await this.#client.execute({
         sql: `SELECT * FROM ${storage.TABLE_SCORERS} ${whereClause} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
         args: [...queryParams, limitValue, start]
       });
@@ -2544,7 +3340,7 @@ var ScoresLibSQL = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_GET_SCORES_BY_SCORER_ID_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "LIST_SCORES_BY_SCORER_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -2552,48 +3348,17 @@ var ScoresLibSQL = class extends storage.ScoresStorage {
       );
     }
   }
+  /**
+   * LibSQL-specific score row transformation.
+   * Maps additionalLLMContext column to additionalContext field.
+   */
   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 requestContextValue = row.requestContext ? storage.safelyParseJSON(row.requestContext) : 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 {
-      id: row.id,
-      traceId: row.traceId,
-      spanId: row.spanId,
-      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,
-      requestContext: requestContextValue,
-      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
-    };
+    return storage.transformScoreRow(row, {
+      fieldMappings: { additionalContext: "additionalLLMContext" }
+    });
   }
   async getScoreById({ id }) {
-    const result = await this.client.execute({
+    const result = await this.#client.execute({
       sql: `SELECT * FROM ${storage.TABLE_SCORERS} WHERE id = ?`,
       args: [id]
     });
@@ -2606,15 +3371,15 @@ var ScoresLibSQL = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_SAVE_SCORE_FAILED_INVALID_SCORE_PAYLOAD",
+          id: storage.createStorageErrorId("LIBSQL", "SAVE_SCORE", "VALIDATION_FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: {
-            scorer: score.scorer.id,
-            entityId: score.entityId,
-            entityType: score.entityType,
-            traceId: score.traceId || "",
-            spanId: score.spanId || ""
+            scorer: typeof score.scorer?.id === "string" ? score.scorer.id : String(score.scorer?.id ?? "unknown"),
+            entityId: score.entityId ?? "unknown",
+            entityType: score.entityType ?? "unknown",
+            traceId: score.traceId ?? "",
+            spanId: score.spanId ?? ""
           }
         },
         error$1
@@ -2622,21 +3387,21 @@ var ScoresLibSQL = class extends storage.ScoresStorage {
     }
     try {
       const id = crypto.randomUUID();
-      await this.operations.insert({
+      const now = /* @__PURE__ */ new Date();
+      await this.#db.insert({
         tableName: storage.TABLE_SCORERS,
         record: {
+          ...parsedScore,
           id,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          ...parsedScore
+          createdAt: now.toISOString(),
+          updatedAt: now.toISOString()
         }
       });
-      const scoreFromDb = await this.getScoreById({ id });
-      return { score: scoreFromDb };
+      return { score: { ...parsedScore, id, createdAt: now, updatedAt: now } };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_SAVE_SCORE_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "SAVE_SCORE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -2651,7 +3416,7 @@ var ScoresLibSQL = class extends storage.ScoresStorage {
   }) {
     try {
       const { page, perPage: perPageInput } = pagination;
-      const countResult = await this.client.execute({
+      const countResult = await this.#client.execute({
         sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_SCORERS} WHERE entityId = ? AND entityType = ?`,
         args: [entityId, entityType]
       });
@@ -2671,7 +3436,7 @@ var ScoresLibSQL = class extends storage.ScoresStorage {
       const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       const limitValue = perPageInput === false ? total : perPage;
       const end = perPageInput === false ? total : start + perPage;
-      const result = await this.client.execute({
+      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, limitValue, start]
       });
@@ -2688,7 +3453,7 @@ var ScoresLibSQL = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_GET_SCORES_BY_ENTITY_ID_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "LIST_SCORES_BY_ENTITY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -2705,14 +3470,14 @@ var ScoresLibSQL = class extends storage.ScoresStorage {
       const { page, perPage: perPageInput } = pagination;
       const perPage = storage.normalizePerPage(perPageInput, 100);
       const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-      const countSQLResult = await this.client.execute({
+      const countSQLResult = await this.#client.execute({
         sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_SCORERS} WHERE traceId = ? AND spanId = ?`,
         args: [traceId, spanId]
       });
       const total = Number(countSQLResult.rows?.[0]?.count ?? 0);
       const limitValue = perPageInput === false ? total : perPage;
       const end = perPageInput === false ? total : start + perPage;
-      const result = await this.client.execute({
+      const result = await this.#client.execute({
         sql: `SELECT * FROM ${storage.TABLE_SCORERS} WHERE traceId = ? AND spanId = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
         args: [traceId, spanId, limitValue, start]
       });
@@ -2729,7 +3494,7 @@ var ScoresLibSQL = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_GET_SCORES_BY_SPAN_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "LIST_SCORES_BY_SPAN", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -2757,37 +3522,49 @@ function parseWorkflowRun(row) {
   };
 }
 var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
-  operations;
-  client;
-  maxRetries;
-  initialBackoffMs;
-  constructor({
-    operations,
-    client,
-    maxRetries = 5,
-    initialBackoffMs = 500
-  }) {
+  #db;
+  #client;
+  executeWithRetry;
+  constructor(config) {
     super();
-    this.operations = operations;
-    this.client = client;
-    this.maxRetries = maxRetries;
-    this.initialBackoffMs = initialBackoffMs;
+    const client = resolveClient(config);
+    const maxRetries = config.maxRetries ?? 5;
+    const initialBackoffMs = config.initialBackoffMs ?? 500;
+    this.#client = client;
+    this.#db = new LibSQLDB({ client, maxRetries, initialBackoffMs });
+    this.executeWithRetry = createExecuteWriteOperationWithRetry({
+      logger: this.logger,
+      maxRetries,
+      initialBackoffMs
+    });
     this.setupPragmaSettings().catch(
       (err) => this.logger.warn("LibSQL Workflows: Failed to setup PRAGMA settings.", err)
     );
   }
+  async init() {
+    const schema = storage.TABLE_SCHEMAS[storage.TABLE_WORKFLOW_SNAPSHOT];
+    await this.#db.createTable({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT, schema });
+    await this.#db.alterTable({
+      tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+      schema,
+      ifNotExists: ["resourceId"]
+    });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.deleteData({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT });
+  }
   async setupPragmaSettings() {
     try {
-      await this.client.execute("PRAGMA busy_timeout = 10000;");
+      await this.#client.execute("PRAGMA busy_timeout = 10000;");
       this.logger.debug("LibSQL Workflows: PRAGMA busy_timeout=10000 set.");
       try {
-        await this.client.execute("PRAGMA journal_mode = WAL;");
+        await this.#client.execute("PRAGMA journal_mode = WAL;");
         this.logger.debug("LibSQL Workflows: PRAGMA journal_mode=WAL set.");
       } catch {
         this.logger.debug("LibSQL Workflows: WAL mode not supported, using default journal mode.");
       }
       try {
-        await this.client.execute("PRAGMA synchronous = NORMAL;");
+        await this.#client.execute("PRAGMA synchronous = NORMAL;");
         this.logger.debug("LibSQL Workflows: PRAGMA synchronous=NORMAL set.");
       } catch {
         this.logger.debug("LibSQL Workflows: Failed to set synchronous mode.");
@@ -2796,44 +3573,6 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
       this.logger.warn("LibSQL Workflows: Failed to set PRAGMA settings.", err);
     }
   }
-  async executeWithRetry(operation) {
-    let attempts = 0;
-    let backoff = this.initialBackoffMs;
-    while (attempts < this.maxRetries) {
-      try {
-        return await operation();
-      } catch (error) {
-        this.logger.debug("LibSQL Workflows: Error caught in retry loop", {
-          errorType: error.constructor.name,
-          errorCode: error.code,
-          errorMessage: error.message,
-          attempts,
-          maxRetries: this.maxRetries
-        });
-        const isLockError = error.code === "SQLITE_BUSY" || error.code === "SQLITE_LOCKED" || error.message?.toLowerCase().includes("database is locked") || error.message?.toLowerCase().includes("database table is locked") || error.message?.toLowerCase().includes("table is locked") || error.constructor.name === "SqliteError" && error.message?.toLowerCase().includes("locked");
-        if (isLockError) {
-          attempts++;
-          if (attempts >= this.maxRetries) {
-            this.logger.error(
-              `LibSQL Workflows: Operation failed after ${this.maxRetries} attempts due to database lock: ${error.message}`,
-              { error, attempts, maxRetries: this.maxRetries }
-            );
-            throw error;
-          }
-          this.logger.warn(
-            `LibSQL Workflows: Attempt ${attempts} failed due to database lock. Retrying in ${backoff}ms...`,
-            { errorMessage: error.message, attempts, backoff, maxRetries: this.maxRetries }
-          );
-          await new Promise((resolve) => setTimeout(resolve, backoff));
-          backoff *= 2;
-        } else {
-          this.logger.error("LibSQL Workflows: Non-lock error occurred, not retrying", { error });
-          throw error;
-        }
-      }
-    }
-    throw new Error("LibSQL Workflows: Max retries reached, but no error was re-thrown from the loop.");
-  }
   async updateWorkflowResults({
     workflowName,
     runId,
@@ -2842,7 +3581,7 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
     requestContext
   }) {
     return this.executeWithRetry(async () => {
-      const tx = await this.client.transaction("write");
+      const tx = await this.#client.transaction("write");
       try {
         const existingSnapshotResult = await tx.execute({
           sql: `SELECT snapshot FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
@@ -2855,11 +3594,12 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
             activePaths: [],
             timestamp: Date.now(),
             suspendedPaths: {},
+            activeStepsPath: {},
             resumeLabels: {},
             serializedStepGraph: [],
+            status: "pending",
             value: {},
             waitingPaths: {},
-            status: "pending",
             runId,
             requestContext: {}
           };
@@ -2881,7 +3621,7 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
         }
         throw error;
       }
-    });
+    }, "updateWorkflowResults");
   }
   async updateWorkflowState({
     workflowName,
@@ -2889,7 +3629,7 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
     opts
   }) {
     return this.executeWithRetry(async () => {
-      const tx = await this.client.transaction("write");
+      const tx = await this.#client.transaction("write");
       try {
         const existingSnapshotResult = await tx.execute({
           sql: `SELECT snapshot FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
@@ -2918,24 +3658,27 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
         }
         throw error;
       }
-    });
+    }, "updateWorkflowState");
   }
   async persistWorkflowSnapshot({
     workflowName,
     runId,
     resourceId,
-    snapshot
+    snapshot,
+    createdAt,
+    updatedAt
   }) {
+    const now = /* @__PURE__ */ new Date();
     const data = {
       workflow_name: workflowName,
       run_id: runId,
       resourceId,
       snapshot,
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
+      createdAt: createdAt ?? now,
+      updatedAt: updatedAt ?? now
     };
     this.logger.debug("Persisting workflow snapshot", { workflowName, runId, data });
-    await this.operations.insert({
+    await this.#db.insert({
       tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
       record: data
     });
@@ -2945,7 +3688,7 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
     runId
   }) {
     this.logger.debug("Loading workflow snapshot", { workflowName, runId });
-    const d = await this.operations.load({
+    const d = await this.#db.select({
       tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
       keys: { workflow_name: workflowName, run_id: runId }
     });
@@ -2967,7 +3710,7 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
     }
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
     try {
-      const result = await this.client.execute({
+      const result = await this.#client.execute({
         sql: `SELECT * FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} ${whereClause} ORDER BY createdAt DESC LIMIT 1`,
         args
       });
@@ -2978,7 +3721,7 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -2986,13 +3729,34 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
       );
     }
   }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    return this.executeWithRetry(async () => {
+      try {
+        await this.#client.execute({
+          sql: `DELETE FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
+          args: [workflowName, runId]
+        });
+      } catch (error$1) {
+        throw new error.MastraError(
+          {
+            id: storage.createStorageErrorId("LIBSQL", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.THIRD_PARTY,
+            details: { runId, workflowName }
+          },
+          error$1
+        );
+      }
+    }, "deleteWorkflowRunById");
+  }
   async listWorkflowRuns({
     workflowName,
     fromDate,
     toDate,
     page,
     perPage,
-    resourceId
+    resourceId,
+    status
   } = {}) {
     try {
       const conditions = [];
@@ -3001,6 +3765,10 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
         conditions.push("workflow_name = ?");
         args.push(workflowName);
       }
+      if (status) {
+        conditions.push("json_extract(snapshot, '$.status') = ?");
+        args.push(status);
+      }
       if (fromDate) {
         conditions.push("createdAt >= ?");
         args.push(fromDate.toISOString());
@@ -3010,7 +3778,7 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
         args.push(toDate.toISOString());
       }
       if (resourceId) {
-        const hasResourceId = await this.operations.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
+        const hasResourceId = await this.#db.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
         if (hasResourceId) {
           conditions.push("resourceId = ?");
           args.push(resourceId);
@@ -3022,7 +3790,7 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
       let total = 0;
       const usePagination = typeof perPage === "number" && typeof page === "number";
       if (usePagination) {
-        const countResult = await this.client.execute({
+        const countResult = await this.#client.execute({
           sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} ${whereClause}`,
           args
         });
@@ -3030,7 +3798,7 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
       }
       const normalizedPerPage = usePagination ? storage.normalizePerPage(perPage, Number.MAX_SAFE_INTEGER) : 0;
       const offset = usePagination ? page * normalizedPerPage : 0;
-      const result = await this.client.execute({
+      const result = await this.#client.execute({
         sql: `SELECT * FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} ${whereClause} ORDER BY createdAt DESC${usePagination ? ` LIMIT ? OFFSET ?` : ""}`,
         args: usePagination ? [...args, normalizedPerPage, offset] : args
       });
@@ -3039,7 +3807,7 @@ var WorkflowsLibSQL = class extends storage.WorkflowsStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "LIBSQL_STORE_LIST_WORKFLOW_RUNS_FAILED",
+          id: storage.createStorageErrorId("LIBSQL", "LIST_WORKFLOW_RUNS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -3059,7 +3827,7 @@ var LibSQLStore = class extends storage.MastraStorage {
     if (!config.id || typeof config.id !== "string" || config.id.trim() === "") {
       throw new Error("LibSQLStore: id must be provided and cannot be empty.");
     }
-    super({ id: config.id, name: `LibSQLStore` });
+    super({ id: config.id, name: `LibSQLStore`, disableInit: config.disableInit });
     this.maxRetries = config.maxRetries ?? 5;
     this.initialBackoffMs = config.initialBackoffMs ?? 100;
     if ("url" in config) {
@@ -3077,214 +3845,24 @@ var LibSQLStore = class extends storage.MastraStorage {
     } else {
       this.client = config.client;
     }
-    const operations = new StoreOperationsLibSQL({
+    const domainConfig = {
       client: this.client,
       maxRetries: this.maxRetries,
       initialBackoffMs: this.initialBackoffMs
-    });
-    const scores = new ScoresLibSQL({ client: this.client, operations });
-    const workflows = new WorkflowsLibSQL({ client: this.client, operations });
-    const memory = new MemoryLibSQL({ client: this.client, operations });
-    const observability = new ObservabilityLibSQL({ operations });
+    };
+    const scores = new ScoresLibSQL(domainConfig);
+    const workflows = new WorkflowsLibSQL(domainConfig);
+    const memory = new MemoryLibSQL(domainConfig);
+    const observability = new ObservabilityLibSQL(domainConfig);
+    const agents = new AgentsLibSQL(domainConfig);
     this.stores = {
-      operations,
       scores,
       workflows,
       memory,
-      observability
-    };
-  }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true,
-      hasColumn: true,
-      createTable: true,
-      deleteMessages: true,
-      observabilityInstance: true,
-      listScoresBySpan: true
+      observability,
+      agents
     };
   }
-  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 });
-  }
-  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 listMessagesById({ messageIds }) {
-    return this.stores.memory.listMessagesById({ messageIds });
-  }
-  async saveMessages(args) {
-    const result = await this.stores.memory.saveMessages({ messages: args.messages });
-    return { messages: result.messages };
-  }
-  async updateMessages({
-    messages
-  }) {
-    return this.stores.memory.updateMessages({ messages });
-  }
-  async deleteMessages(messageIds) {
-    return this.stores.memory.deleteMessages(messageIds);
-  }
-  async getScoreById({ id }) {
-    return this.stores.scores.getScoreById({ id });
-  }
-  async saveScore(score) {
-    return this.stores.scores.saveScore(score);
-  }
-  async listScoresByScorerId({
-    scorerId,
-    entityId,
-    entityType,
-    source,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByScorerId({ scorerId, entityId, entityType, source, pagination });
-  }
-  async listScoresByRunId({
-    runId,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByRunId({ runId, pagination });
-  }
-  async listScoresByEntityId({
-    entityId,
-    entityType,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByEntityId({ entityId, entityType, pagination });
-  }
-  /**
-   * WORKFLOWS
-   */
-  async updateWorkflowResults({
-    workflowName,
-    runId,
-    stepId,
-    result,
-    requestContext
-  }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
-  }
-  async updateWorkflowState({
-    workflowName,
-    runId,
-    opts
-  }) {
-    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
-  }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    resourceId,
-    snapshot
-  }) {
-    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot });
-  }
-  async loadWorkflowSnapshot({
-    workflowName,
-    runId
-  }) {
-    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
-  }
-  async listWorkflowRuns({
-    workflowName,
-    fromDate,
-    toDate,
-    perPage,
-    page,
-    resourceId
-  } = {}) {
-    return this.stores.workflows.listWorkflowRuns({ workflowName, fromDate, toDate, perPage, page, resourceId });
-  }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
-    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
-  }
-  async getResourceById({ resourceId }) {
-    return this.stores.memory.getResourceById({ resourceId });
-  }
-  async saveResource({ resource }) {
-    return this.stores.memory.saveResource({ resource });
-  }
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata
-  }) {
-    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
-  }
-  async createSpan(span) {
-    return this.stores.observability.createSpan(span);
-  }
-  async updateSpan(params) {
-    return this.stores.observability.updateSpan(params);
-  }
-  async getTrace(traceId) {
-    return this.stores.observability.getTrace(traceId);
-  }
-  async getTracesPaginated(args) {
-    return this.stores.observability.getTracesPaginated(args);
-  }
-  async listScoresBySpan({
-    traceId,
-    spanId,
-    pagination
-  }) {
-    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
-  }
-  async batchCreateSpans(args) {
-    return this.stores.observability.batchCreateSpans(args);
-  }
-  async batchUpdateSpans(args) {
-    return this.stores.observability.batchUpdateSpans(args);
-  }
 };
 
 // src/vector/prompt.ts
@@ -3386,9 +3964,14 @@ Example Complex Query:
   ]
 }`;
 
+exports.AgentsLibSQL = AgentsLibSQL;
 exports.DefaultStorage = LibSQLStore;
 exports.LIBSQL_PROMPT = LIBSQL_PROMPT;
 exports.LibSQLStore = LibSQLStore;
 exports.LibSQLVector = LibSQLVector;
+exports.MemoryLibSQL = MemoryLibSQL;
+exports.ObservabilityLibSQL = ObservabilityLibSQL;
+exports.ScoresLibSQL = ScoresLibSQL;
+exports.WorkflowsLibSQL = WorkflowsLibSQL;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map