@mastra/libsql 1.0.0-beta.9 → 1.0.0

package/dist/index.js

@@ -1,8 +1,8 @@
 import { createClient } from '@libsql/client';
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
-import { createVectorErrorId, MastraStorage, ScoresStorage, SCORERS_SCHEMA, TABLE_SCORERS, normalizePerPage, calculatePagination, createStorageErrorId, transformScoreRow, WorkflowsStorage, TABLE_SCHEMAS, TABLE_WORKFLOW_SNAPSHOT, MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, ObservabilityStorage, SPAN_SCHEMA, TABLE_SPANS, listTracesArgsSchema, AgentsStorage, AGENTS_SCHEMA, TABLE_AGENTS, getSqlType, TraceStatus, safelyParseJSON } from '@mastra/core/storage';
+import { createVectorErrorId, AgentsStorage, AGENTS_SCHEMA, TABLE_AGENTS, createStorageErrorId, normalizePerPage, calculatePagination, MemoryStorage, TABLE_SCHEMAS, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, ObservabilityStorage, SPAN_SCHEMA, TABLE_SPANS, listTracesArgsSchema, ScoresStorage, SCORERS_SCHEMA, TABLE_SCORERS, transformScoreRow, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, MastraCompositeStore, TraceStatus, getSqlType, safelyParseJSON } from '@mastra/core/storage';
 import { parseSqlIdentifier, parseFieldKey } from '@mastra/core/utils';
-import { MastraVector } from '@mastra/core/vector';
+import { MastraVector, validateTopK, validateUpsertInput } from '@mastra/core/vector';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 import { MastraBase } from '@mastra/core/base';
 import { MessageList } from '@mastra/core/agent';
@@ -242,10 +242,10 @@ var FILTER_OPERATORS = {
     };
   },
   // Element Operators
-  $exists: (key) => {
+  $exists: (key, value) => {
     const jsonPath = getJsonPath(key);
     return {
-      sql: `json_extract(metadata, ${jsonPath}) IS NOT NULL`,
+      sql: value === false ? `json_extract(metadata, ${jsonPath}) IS NULL` : `json_extract(metadata, ${jsonPath}) IS NOT NULL`,
       needsValue: false
     };
   },
@@ -509,7 +509,7 @@ var LibSQLVector = class extends MastraVector {
   maxRetries;
   initialBackoffMs;
   constructor({
-    connectionUrl,
+    url,
     authToken,
     syncUrl,
     syncInterval,
@@ -519,14 +519,14 @@ var LibSQLVector = class extends MastraVector {
   }) {
     super({ id });
     this.turso = createClient({
-      url: connectionUrl,
+      url,
       syncUrl,
       authToken,
       syncInterval
     });
     this.maxRetries = maxRetries;
     this.initialBackoffMs = initialBackoffMs;
-    if (connectionUrl.includes(`file:`) || connectionUrl.includes(`:memory:`)) {
+    if (url.includes(`file:`) || url.includes(`:memory:`)) {
       this.turso.execute("PRAGMA journal_mode=WAL;").then(() => this.logger.debug("LibSQLStore: PRAGMA journal_mode=WAL set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA journal_mode=WAL.", err));
       this.turso.execute("PRAGMA busy_timeout = 5000;").then(() => this.logger.debug("LibSQLStore: PRAGMA busy_timeout=5000 set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA busy_timeout=5000.", err));
     }
@@ -538,7 +538,7 @@ var LibSQLVector = class extends MastraVector {
       try {
         return await operation();
       } catch (error) {
-        if (error.code === "SQLITE_BUSY" || error.message && error.message.toLowerCase().includes("database is locked")) {
+        if (error.code === "SQLITE_BUSY" || error.code === "SQLITE_LOCKED" || error.code === "SQLITE_LOCKED_SHAREDCACHE" || error.message && error.message.toLowerCase().includes("database is locked") || error.message && error.message.toLowerCase().includes("database table is locked")) {
           attempts++;
           if (attempts >= this.maxRetries) {
             this.logger.error(
@@ -572,22 +572,14 @@ var LibSQLVector = class extends MastraVector {
     minScore = -1
     // Default to -1 to include all results (cosine similarity ranges from -1 to 1)
   }) {
-    try {
-      if (!Number.isInteger(topK) || topK <= 0) {
-        throw new Error("topK must be a positive integer");
-      }
-      if (!Array.isArray(queryVector) || !queryVector.every((x) => typeof x === "number" && Number.isFinite(x))) {
-        throw new Error("queryVector must be an array of finite numbers");
-      }
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: createVectorErrorId("LIBSQL", "QUERY", "INVALID_ARGS"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.USER
-        },
-        error
-      );
+    validateTopK("LIBSQL", topK);
+    if (!Array.isArray(queryVector) || !queryVector.every((x) => typeof x === "number" && Number.isFinite(x))) {
+      throw new MastraError({
+        id: createVectorErrorId("LIBSQL", "QUERY", "INVALID_ARGS"),
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        details: { message: "queryVector must be an array of finite numbers" }
+      });
     }
     try {
       const parsedIndexName = parseSqlIdentifier(indexName, "index name");
@@ -647,6 +639,7 @@ var LibSQLVector = class extends MastraVector {
     }
   }
   async doUpsert({ indexName, vectors, metadata, ids }) {
+    validateUpsertInput("LIBSQL", vectors, metadata, ids);
     const tx = await this.turso.transaction("write");
     try {
       const parsedIndexName = parseSqlIdentifier(indexName, "index name");
@@ -1093,6 +1086,14 @@ var LibSQLVector = class extends MastraVector {
     });
   }
 };
+function buildSelectColumns(tableName) {
+  const schema = TABLE_SCHEMAS[tableName];
+  return Object.keys(schema).map((col) => {
+    const colDef = schema[col];
+    const parsedCol = parseSqlIdentifier(col, "column name");
+    return colDef?.type === "jsonb" ? `json(${parsedCol}) as ${parsedCol}` : parsedCol;
+  }).join(", ");
+}
 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");
 }
@@ -1141,17 +1142,27 @@ function createExecuteWriteOperationWithRetry({
 }
 function prepareStatement({ tableName, record }) {
   const parsedTableName = parseSqlIdentifier(tableName, "table name");
-  const columns = Object.keys(record).map((col) => parseSqlIdentifier(col, "column name"));
-  const values = Object.values(record).map((v) => {
+  const schema = TABLE_SCHEMAS[tableName];
+  const columnNames = Object.keys(record);
+  const columns = columnNames.map((col) => parseSqlIdentifier(col, "column name"));
+  const values = columnNames.map((col) => {
+    const v = record[col];
     if (typeof v === `undefined` || v === null) {
       return null;
     }
+    const colDef = schema[col];
+    if (colDef?.type === "jsonb") {
+      return JSON.stringify(v);
+    }
     if (v instanceof Date) {
       return v.toISOString();
     }
     return typeof v === "object" ? JSON.stringify(v) : v;
   });
-  const placeholders = values.map(() => "?").join(", ");
+  const placeholders = columnNames.map((col) => {
+    const colDef = schema[col];
+    return colDef?.type === "jsonb" ? "jsonb(?)" : "?";
+  }).join(", ");
   return {
     sql: `INSERT OR REPLACE INTO ${parsedTableName} (${columns.join(", ")}) VALUES (${placeholders})`,
     args: values
@@ -1164,19 +1175,33 @@ function prepareUpdateStatement({
 }) {
   const parsedTableName = parseSqlIdentifier(tableName, "table name");
   const schema = TABLE_SCHEMAS[tableName];
-  const updateColumns = Object.keys(updates).map((col) => parseSqlIdentifier(col, "column name"));
-  const updateValues = Object.values(updates).map(transformToSqlValue);
-  const setClause = updateColumns.map((col) => `${col} = ?`).join(", ");
+  const updateColumnNames = Object.keys(updates);
+  const updateColumns = updateColumnNames.map((col) => parseSqlIdentifier(col, "column name"));
+  const updateValues = updateColumnNames.map((col) => {
+    const colDef = schema[col];
+    const v = updates[col];
+    if (colDef?.type === "jsonb") {
+      return transformToSqlValue(v, true);
+    }
+    return transformToSqlValue(v, false);
+  });
+  const setClause = updateColumns.map((col, i) => {
+    const colDef = schema[updateColumnNames[i]];
+    return colDef?.type === "jsonb" ? `${col} = jsonb(?)` : `${col} = ?`;
+  }).join(", ");
   const whereClause = prepareWhereClause(keys, schema);
   return {
     sql: `UPDATE ${parsedTableName} SET ${setClause}${whereClause.sql}`,
     args: [...updateValues, ...whereClause.args]
   };
 }
-function transformToSqlValue(value) {
+function transformToSqlValue(value, forceJsonStringify = false) {
   if (typeof value === "undefined" || value === null) {
     return null;
   }
+  if (forceJsonStringify) {
+    return JSON.stringify(value);
+  }
   if (value instanceof Date) {
     return value.toISOString();
   }
@@ -1533,11 +1558,12 @@ var LibSQLDB = class extends MastraBase {
    */
   async select({ tableName, keys }) {
     const parsedTableName = parseSqlIdentifier(tableName, "table name");
+    const columns = buildSelectColumns(tableName);
     const parsedKeys = Object.keys(keys).map((key) => 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`,
+      sql: `SELECT ${columns} FROM ${parsedTableName} WHERE ${conditions} ORDER BY createdAt DESC LIMIT 1`,
       args: values
     });
     if (!result.rows || result.rows.length === 0) {
@@ -1577,7 +1603,8 @@ var LibSQLDB = class extends MastraBase {
     args
   }) {
     const parsedTableName = parseSqlIdentifier(tableName, "table name");
-    let statement = `SELECT * FROM ${parsedTableName}`;
+    const columns = buildSelectColumns(tableName);
+    let statement = `SELECT ${columns} FROM ${parsedTableName}`;
     if (whereClause?.sql) {
       statement += ` ${whereClause.sql}`;
     }
@@ -1594,7 +1621,17 @@ var LibSQLDB = class extends MastraBase {
       sql: statement,
       args: [...whereClause?.args ?? [], ...args ?? []]
     });
-    return result.rows;
+    return (result.rows ?? []).map((row) => {
+      return 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];
+          }
+        })
+      );
+    });
   }
   /**
    * Returns the total count of records matching the optional WHERE clause.
@@ -1638,7 +1675,7 @@ var LibSQLDB = class extends MastraBase {
       // SQLite uses 0/1 for booleans
       case "jsonb":
         return "TEXT";
-      // Store JSON as TEXT in SQLite
+      // SQLite: column stores TEXT, we use jsonb()/json() functions for binary optimization
       default:
         return getSqlType(type);
     }
@@ -1666,6 +1703,9 @@ var LibSQLDB = class extends MastraBase {
       if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
         tableConstraints.push("UNIQUE (workflow_name, run_id)");
       }
+      if (tableName === TABLE_SPANS) {
+        tableConstraints.push("UNIQUE (spanId, traceId)");
+      }
       const allDefinitions = [...columnDefinitions, ...tableConstraints].join(",\n  ");
       const sql = `CREATE TABLE IF NOT EXISTS ${parsedTableName} (
   ${allDefinitions}
@@ -1676,6 +1716,9 @@ var LibSQLDB = class extends MastraBase {
         await this.migrateSpansTable();
       }
     } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
       throw new MastraError(
         {
           id: createStorageErrorId("LIBSQL", "CREATE_TABLE", "FAILED"),
@@ -1689,7 +1732,7 @@ var LibSQLDB = class extends MastraBase {
   }
   /**
    * Migrates the spans table schema from OLD_SPAN_SCHEMA to current SPAN_SCHEMA.
-   * This adds new columns that don't exist in old schema.
+   * This adds new columns that don't exist in old schema and ensures required indexes exist.
    */
   async migrateSpansTable() {
     const schema = TABLE_SCHEMAS[TABLE_SPANS];
@@ -1703,11 +1746,205 @@ var LibSQLDB = class extends MastraBase {
           this.logger.debug(`LibSQLDB: Added column '${columnName}' to ${TABLE_SPANS}`);
         }
       }
+      const indexExists = await this.spansUniqueIndexExists();
+      if (!indexExists) {
+        const duplicateInfo = await this.checkForDuplicateSpans();
+        if (duplicateInfo.hasDuplicates) {
+          const errorMessage = `
+===========================================================================
+MIGRATION REQUIRED: Duplicate spans detected in ${TABLE_SPANS}
+===========================================================================
+
+Found ${duplicateInfo.duplicateCount} duplicate (traceId, spanId) combinations.
+
+The spans table requires a unique constraint on (traceId, spanId), but your
+database contains duplicate entries that must be resolved first.
+
+To fix this, run the manual migration command:
+
+  npx mastra migrate
+
+This command will:
+  1. Remove duplicate spans (keeping the most complete/recent version)
+  2. Add the required unique constraint
+
+Note: This migration may take some time for large tables.
+===========================================================================
+`;
+          throw new MastraError({
+            id: createStorageErrorId("LIBSQL", "MIGRATION_REQUIRED", "DUPLICATE_SPANS"),
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.USER,
+            text: errorMessage
+          });
+        } else {
+          await this.client.execute(
+            `CREATE UNIQUE INDEX IF NOT EXISTS "mastra_ai_spans_spanid_traceid_idx" ON "${TABLE_SPANS}" ("spanId", "traceId")`
+          );
+          this.logger.debug(`LibSQLDB: Created unique index on (spanId, traceId) for ${TABLE_SPANS}`);
+        }
+      }
       this.logger.info(`LibSQLDB: Migration completed for ${TABLE_SPANS}`);
     } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
       this.logger.warn(`LibSQLDB: Failed to migrate spans table ${TABLE_SPANS}:`, error);
     }
   }
+  /**
+   * Checks if the unique index on (spanId, traceId) already exists on the spans table.
+   * Used to skip deduplication when the index already exists (migration already complete).
+   */
+  async spansUniqueIndexExists() {
+    try {
+      const result = await this.client.execute(
+        `SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = 'mastra_ai_spans_spanid_traceid_idx'`
+      );
+      return (result.rows?.length ?? 0) > 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Checks for duplicate (traceId, spanId) combinations in the spans table.
+   * Returns information about duplicates for logging/CLI purposes.
+   */
+  async checkForDuplicateSpans() {
+    try {
+      const result = await this.client.execute(`
+        SELECT COUNT(*) as duplicate_count FROM (
+          SELECT "spanId", "traceId"
+          FROM "${TABLE_SPANS}"
+          GROUP BY "spanId", "traceId"
+          HAVING COUNT(*) > 1
+        )
+      `);
+      const duplicateCount = Number(result.rows?.[0]?.duplicate_count ?? 0);
+      return {
+        hasDuplicates: duplicateCount > 0,
+        duplicateCount
+      };
+    } catch (error) {
+      this.logger.debug(`LibSQLDB: Could not check for duplicates: ${error}`);
+      return { hasDuplicates: false, duplicateCount: 0 };
+    }
+  }
+  /**
+   * Manually run the spans migration to deduplicate and add the unique constraint.
+   * This is intended to be called from the CLI when duplicates are detected.
+   *
+   * @returns Migration result with status and details
+   */
+  async migrateSpans() {
+    const indexExists = await this.spansUniqueIndexExists();
+    if (indexExists) {
+      return {
+        success: true,
+        alreadyMigrated: true,
+        duplicatesRemoved: 0,
+        message: `Migration already complete. Unique index exists on ${TABLE_SPANS}.`
+      };
+    }
+    const duplicateInfo = await this.checkForDuplicateSpans();
+    if (duplicateInfo.hasDuplicates) {
+      this.logger.info(
+        `Found ${duplicateInfo.duplicateCount} duplicate (traceId, spanId) combinations. Starting deduplication...`
+      );
+      await this.deduplicateSpans();
+    } else {
+      this.logger.info(`No duplicate spans found.`);
+    }
+    await this.client.execute(
+      `CREATE UNIQUE INDEX IF NOT EXISTS "mastra_ai_spans_spanid_traceid_idx" ON "${TABLE_SPANS}" ("spanId", "traceId")`
+    );
+    return {
+      success: true,
+      alreadyMigrated: false,
+      duplicatesRemoved: duplicateInfo.duplicateCount,
+      message: duplicateInfo.hasDuplicates ? `Migration complete. Removed duplicates and added unique index to ${TABLE_SPANS}.` : `Migration complete. Added unique index to ${TABLE_SPANS}.`
+    };
+  }
+  /**
+   * Check migration status for the spans table.
+   * Returns information about whether migration is needed.
+   */
+  async checkSpansMigrationStatus() {
+    const indexExists = await this.spansUniqueIndexExists();
+    if (indexExists) {
+      return {
+        needsMigration: false,
+        hasDuplicates: false,
+        duplicateCount: 0,
+        constraintExists: true,
+        tableName: TABLE_SPANS
+      };
+    }
+    const duplicateInfo = await this.checkForDuplicateSpans();
+    return {
+      needsMigration: true,
+      hasDuplicates: duplicateInfo.hasDuplicates,
+      duplicateCount: duplicateInfo.duplicateCount,
+      constraintExists: false,
+      tableName: TABLE_SPANS
+    };
+  }
+  /**
+   * Deduplicates spans table by removing duplicate (spanId, traceId) combinations.
+   * Keeps the "best" record for each duplicate group based on:
+   * 1. Completed spans (endedAt IS NOT NULL) over incomplete ones
+   * 2. Most recently updated (updatedAt DESC)
+   * 3. Most recently created (createdAt DESC) as tiebreaker
+   */
+  async deduplicateSpans() {
+    try {
+      const duplicateCheck = await this.client.execute(`
+        SELECT COUNT(*) as duplicate_count FROM (
+          SELECT "spanId", "traceId"
+          FROM "${TABLE_SPANS}"
+          GROUP BY "spanId", "traceId"
+          HAVING COUNT(*) > 1
+        )
+      `);
+      const duplicateCount = Number(duplicateCheck.rows?.[0]?.duplicate_count ?? 0);
+      if (duplicateCount === 0) {
+        this.logger.debug(`LibSQLDB: No duplicate spans found, skipping deduplication`);
+        return;
+      }
+      this.logger.warn(`LibSQLDB: Found ${duplicateCount} duplicate (spanId, traceId) combinations, deduplicating...`);
+      const deleteResult = await this.client.execute(`
+        DELETE FROM "${TABLE_SPANS}"
+        WHERE rowid NOT IN (
+          SELECT MIN(best_rowid) FROM (
+            SELECT
+              rowid as best_rowid,
+              "spanId",
+              "traceId",
+              ROW_NUMBER() OVER (
+                PARTITION BY "spanId", "traceId"
+                ORDER BY
+                  CASE WHEN "endedAt" IS NOT NULL THEN 0 ELSE 1 END,
+                  "updatedAt" DESC,
+                  "createdAt" DESC
+              ) as rn
+            FROM "${TABLE_SPANS}"
+          ) ranked
+          WHERE rn = 1
+          GROUP BY "spanId", "traceId"
+        )
+        AND ("spanId", "traceId") IN (
+          SELECT "spanId", "traceId"
+          FROM "${TABLE_SPANS}"
+          GROUP BY "spanId", "traceId"
+          HAVING COUNT(*) > 1
+        )
+      `);
+      const deletedCount = deleteResult.rowsAffected ?? 0;
+      this.logger.warn(`LibSQLDB: Deleted ${deletedCount} duplicate span records`);
+    } catch (error) {
+      this.logger.warn(`LibSQLDB: Failed to deduplicate spans:`, error);
+    }
+  }
   /**
    * Gets a default value for a column type (used when adding NOT NULL columns).
    */
@@ -2210,13 +2447,15 @@ var MemoryLibSQL = class extends MemoryStorage {
         queryParams.push(resourceId);
       }
       if (filter?.dateRange?.start) {
-        conditions.push(`"createdAt" >= ?`);
+        const startOp = filter.dateRange.startExclusive ? ">" : ">=";
+        conditions.push(`"createdAt" ${startOp} ?`);
         queryParams.push(
           filter.dateRange.start instanceof Date ? filter.dateRange.start.toISOString() : filter.dateRange.start
         );
       }
       if (filter?.dateRange?.end) {
-        conditions.push(`"createdAt" <= ?`);
+        const endOp = filter.dateRange.endExclusive ? "<" : "<=";
+        conditions.push(`"createdAt" ${endOp} ?`);
         queryParams.push(
           filter.dateRange.end instanceof Date ? filter.dateRange.end.toISOString() : filter.dateRange.end
         );
@@ -2522,8 +2761,8 @@ var MemoryLibSQL = class extends MemoryStorage {
     await this.#db.insert({
       tableName: TABLE_RESOURCES,
       record: {
-        ...resource,
-        metadata: JSON.stringify(resource.metadata)
+        ...resource
+        // metadata is handled by prepareStatement which stringifies jsonb columns
       }
     });
     return resource;
@@ -2560,7 +2799,7 @@ var MemoryLibSQL = class extends MemoryStorage {
       values.push(workingMemory);
     }
     if (metadata) {
-      updates.push("metadata = ?");
+      updates.push("metadata = jsonb(?)");
       values.push(JSON.stringify(updatedResource.metadata));
     }
     updates.push("updatedAt = ?");
@@ -2599,33 +2838,76 @@ var MemoryLibSQL = class extends MemoryStorage {
       );
     }
   }
-  async listThreadsByResourceId(args) {
-    const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
-    if (page < 0) {
+  async listThreads(args) {
+    const { page = 0, perPage: perPageInput, orderBy, filter } = args;
+    try {
+      this.validatePaginationInput(page, perPageInput ?? 100);
+    } catch (error) {
       throw new MastraError(
         {
-          id: createStorageErrorId("LIBSQL", "LIST_THREADS_BY_RESOURCE_ID", "INVALID_PAGE"),
+          id: createStorageErrorId("LIBSQL", "LIST_THREADS", "INVALID_PAGE"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.USER,
-          details: { page }
+          details: { page, ...perPageInput !== void 0 && { perPage: perPageInput } }
         },
-        new Error("page must be >= 0")
+        error instanceof Error ? error : new Error("Invalid pagination parameters")
       );
     }
     const perPage = normalizePerPage(perPageInput, 100);
+    try {
+      this.validateMetadataKeys(filter?.metadata);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "LIST_THREADS", "INVALID_METADATA_KEY"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { metadataKeys: filter?.metadata ? Object.keys(filter.metadata).join(", ") : "" }
+        },
+        error instanceof Error ? error : new Error("Invalid metadata key")
+      );
+    }
     const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
     const { field, direction } = this.parseOrderBy(orderBy);
     try {
-      const baseQuery = `FROM ${TABLE_THREADS} WHERE resourceId = ?`;
-      const queryParams = [resourceId];
+      const whereClauses = [];
+      const queryParams = [];
+      if (filter?.resourceId) {
+        whereClauses.push("resourceId = ?");
+        queryParams.push(filter.resourceId);
+      }
+      if (filter?.metadata && Object.keys(filter.metadata).length > 0) {
+        for (const [key, value] of Object.entries(filter.metadata)) {
+          if (value === null) {
+            whereClauses.push(`json_extract(metadata, '$.${key}') IS NULL`);
+          } else if (typeof value === "boolean") {
+            whereClauses.push(`json_extract(metadata, '$.${key}') = ?`);
+            queryParams.push(value ? 1 : 0);
+          } else if (typeof value === "number") {
+            whereClauses.push(`json_extract(metadata, '$.${key}') = ?`);
+            queryParams.push(value);
+          } else if (typeof value === "string") {
+            whereClauses.push(`json_extract(metadata, '$.${key}') = ?`);
+            queryParams.push(value);
+          } else {
+            throw new MastraError({
+              id: createStorageErrorId("LIBSQL", "LIST_THREADS", "INVALID_METADATA_VALUE"),
+              domain: ErrorDomain.STORAGE,
+              category: ErrorCategory.USER,
+              text: `Metadata filter value for key "${key}" must be a scalar type (string, number, boolean, or null), got ${typeof value}`,
+              details: { key, valueType: typeof value }
+            });
+          }
+        }
+      }
+      const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+      const baseQuery = `FROM ${TABLE_THREADS} ${whereClause}`;
       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({
@@ -2644,7 +2926,7 @@ var MemoryLibSQL = class extends MemoryStorage {
       }
       const limitValue = perPageInput === false ? total : perPage;
       const dataResult = await this.#client.execute({
-        sql: `SELECT * ${baseQuery} ORDER BY "${field}" ${direction} LIMIT ? OFFSET ?`,
+        sql: `SELECT ${buildSelectColumns(TABLE_THREADS)} ${baseQuery} ORDER BY "${field}" ${direction} LIMIT ? OFFSET ?`,
         args: [...queryParams, limitValue, offset]
       });
       const threads = (dataResult.rows || []).map(mapRowToStorageThreadType);
@@ -2656,12 +2938,18 @@ var MemoryLibSQL = class extends MemoryStorage {
         hasMore: perPageInput === false ? false : offset + perPage < total
       };
     } catch (error) {
+      if (error instanceof MastraError && error.category === ErrorCategory.USER) {
+        throw error;
+      }
       const mastraError = new MastraError(
         {
-          id: createStorageErrorId("LIBSQL", "LIST_THREADS_BY_RESOURCE_ID", "FAILED"),
+          id: createStorageErrorId("LIBSQL", "LIST_THREADS", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { resourceId }
+          details: {
+            ...filter?.resourceId && { resourceId: filter.resourceId },
+            hasMetadataFilter: !!filter?.metadata
+          }
         },
         error
       );
@@ -2681,8 +2969,8 @@ var MemoryLibSQL = class extends MemoryStorage {
       await this.#db.insert({
         tableName: TABLE_THREADS,
         record: {
-          ...thread,
-          metadata: JSON.stringify(thread.metadata)
+          ...thread
+          // metadata is handled by prepareStatement which stringifies jsonb columns
         }
       });
       return thread;
@@ -2729,7 +3017,7 @@ var MemoryLibSQL = class extends MemoryStorage {
     };
     try {
       await this.#client.execute({
-        sql: `UPDATE ${TABLE_THREADS} SET title = ?, metadata = ? WHERE id = ?`,
+        sql: `UPDATE ${TABLE_THREADS} SET title = ?, metadata = jsonb(?) WHERE id = ?`,
         args: [title, JSON.stringify(updatedThread.metadata), id]
       });
       return updatedThread;
@@ -2768,6 +3056,148 @@ var MemoryLibSQL = class extends MemoryStorage {
       );
     }
   }
+  async cloneThread(args) {
+    const { sourceThreadId, newThreadId: providedThreadId, resourceId, title, metadata, options } = args;
+    const sourceThread = await this.getThreadById({ threadId: sourceThreadId });
+    if (!sourceThread) {
+      throw new MastraError({
+        id: createStorageErrorId("LIBSQL", "CLONE_THREAD", "SOURCE_NOT_FOUND"),
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: `Source thread with id ${sourceThreadId} not found`,
+        details: { sourceThreadId }
+      });
+    }
+    const newThreadId = providedThreadId || crypto.randomUUID();
+    const existingThread = await this.getThreadById({ threadId: newThreadId });
+    if (existingThread) {
+      throw new MastraError({
+        id: createStorageErrorId("LIBSQL", "CLONE_THREAD", "THREAD_EXISTS"),
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: `Thread with id ${newThreadId} already exists`,
+        details: { newThreadId }
+      });
+    }
+    try {
+      let messageQuery = `SELECT id, content, role, type, "createdAt", thread_id, "resourceId"
+                          FROM "${TABLE_MESSAGES}" WHERE thread_id = ?`;
+      const messageParams = [sourceThreadId];
+      if (options?.messageFilter?.startDate) {
+        messageQuery += ` AND "createdAt" >= ?`;
+        messageParams.push(
+          options.messageFilter.startDate instanceof Date ? options.messageFilter.startDate.toISOString() : options.messageFilter.startDate
+        );
+      }
+      if (options?.messageFilter?.endDate) {
+        messageQuery += ` AND "createdAt" <= ?`;
+        messageParams.push(
+          options.messageFilter.endDate instanceof Date ? options.messageFilter.endDate.toISOString() : options.messageFilter.endDate
+        );
+      }
+      if (options?.messageFilter?.messageIds && options.messageFilter.messageIds.length > 0) {
+        messageQuery += ` AND id IN (${options.messageFilter.messageIds.map(() => "?").join(", ")})`;
+        messageParams.push(...options.messageFilter.messageIds);
+      }
+      messageQuery += ` ORDER BY "createdAt" ASC`;
+      if (options?.messageLimit && options.messageLimit > 0) {
+        const limitQuery = `SELECT * FROM (${messageQuery.replace('ORDER BY "createdAt" ASC', 'ORDER BY "createdAt" DESC')} LIMIT ?) ORDER BY "createdAt" ASC`;
+        messageParams.push(options.messageLimit);
+        messageQuery = limitQuery;
+      }
+      const sourceMessagesResult = await this.#client.execute({ sql: messageQuery, args: messageParams });
+      const sourceMessages = sourceMessagesResult.rows || [];
+      const now = /* @__PURE__ */ new Date();
+      const nowStr = now.toISOString();
+      const lastMessageId = sourceMessages.length > 0 ? sourceMessages[sourceMessages.length - 1].id : void 0;
+      const cloneMetadata = {
+        sourceThreadId,
+        clonedAt: now,
+        ...lastMessageId && { lastMessageId }
+      };
+      const newThread = {
+        id: newThreadId,
+        resourceId: resourceId || sourceThread.resourceId,
+        title: title || (sourceThread.title ? `Clone of ${sourceThread.title}` : void 0),
+        metadata: {
+          ...metadata,
+          clone: cloneMetadata
+        },
+        createdAt: now,
+        updatedAt: now
+      };
+      const tx = await this.#client.transaction("write");
+      try {
+        await tx.execute({
+          sql: `INSERT INTO "${TABLE_THREADS}" (id, "resourceId", title, metadata, "createdAt", "updatedAt")
+                VALUES (?, ?, ?, jsonb(?), ?, ?)`,
+          args: [
+            newThread.id,
+            newThread.resourceId,
+            newThread.title || null,
+            JSON.stringify(newThread.metadata),
+            nowStr,
+            nowStr
+          ]
+        });
+        const clonedMessages = [];
+        const targetResourceId = resourceId || sourceThread.resourceId;
+        for (const sourceMsg of sourceMessages) {
+          const newMessageId = crypto.randomUUID();
+          const contentStr = sourceMsg.content;
+          let parsedContent;
+          try {
+            parsedContent = JSON.parse(contentStr);
+          } catch {
+            parsedContent = { format: 2, parts: [{ type: "text", text: contentStr }] };
+          }
+          await tx.execute({
+            sql: `INSERT INTO "${TABLE_MESSAGES}" (id, thread_id, content, role, type, "createdAt", "resourceId")
+                  VALUES (?, ?, ?, ?, ?, ?, ?)`,
+            args: [
+              newMessageId,
+              newThreadId,
+              contentStr,
+              sourceMsg.role,
+              sourceMsg.type || "v2",
+              sourceMsg.createdAt,
+              targetResourceId
+            ]
+          });
+          clonedMessages.push({
+            id: newMessageId,
+            threadId: newThreadId,
+            content: parsedContent,
+            role: sourceMsg.role,
+            type: sourceMsg.type || void 0,
+            createdAt: new Date(sourceMsg.createdAt),
+            resourceId: targetResourceId
+          });
+        }
+        await tx.commit();
+        return {
+          thread: newThread,
+          clonedMessages
+        };
+      } catch (error) {
+        await tx.rollback();
+        throw error;
+      }
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "CLONE_THREAD", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { sourceThreadId, newThreadId }
+        },
+        error
+      );
+    }
+  }
 };
 var ObservabilityLibSQL = class extends ObservabilityStorage {
   #db;
@@ -2782,6 +3212,22 @@ var ObservabilityLibSQL = class extends ObservabilityStorage {
   async dangerouslyClearAll() {
     await this.#db.deleteData({ tableName: TABLE_SPANS });
   }
+  /**
+   * Manually run the spans migration to deduplicate and add the unique constraint.
+   * This is intended to be called from the CLI when duplicates are detected.
+   *
+   * @returns Migration result with status and details
+   */
+  async migrateSpans() {
+    return this.#db.migrateSpans();
+  }
+  /**
+   * Check migration status for the spans table.
+   * Returns information about whether migration is needed.
+   */
+  async checkSpansMigrationStatus() {
+    return this.#db.checkSpansMigrationStatus();
+  }
   get tracingStrategy() {
     return {
       preferred: "batch-with-updates",
@@ -3249,7 +3695,7 @@ var ScoresLibSQL = class extends ScoresStorage {
       const limitValue = perPageInput === false ? total : perPage;
       const end = perPageInput === false ? total : start + perPage;
       const result = await this.#client.execute({
-        sql: `SELECT * FROM ${TABLE_SCORERS} WHERE runId = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        sql: `SELECT ${buildSelectColumns(TABLE_SCORERS)} FROM ${TABLE_SCORERS} WHERE runId = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
         args: [runId, limitValue, start]
       });
       const scores = result.rows?.map((row) => this.transformScoreRow(row)) ?? [];
@@ -3322,7 +3768,7 @@ var ScoresLibSQL = class extends ScoresStorage {
       const limitValue = perPageInput === false ? total : perPage;
       const end = perPageInput === false ? total : start + perPage;
       const result = await this.#client.execute({
-        sql: `SELECT * FROM ${TABLE_SCORERS} ${whereClause} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        sql: `SELECT ${buildSelectColumns(TABLE_SCORERS)} FROM ${TABLE_SCORERS} ${whereClause} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
         args: [...queryParams, limitValue, start]
       });
       const scores = result.rows?.map((row) => this.transformScoreRow(row)) ?? [];
@@ -3348,16 +3794,13 @@ var ScoresLibSQL = class extends ScoresStorage {
   }
   /**
    * LibSQL-specific score row transformation.
-   * Maps additionalLLMContext column to additionalContext field.
    */
   transformScoreRow(row) {
-    return transformScoreRow(row, {
-      fieldMappings: { additionalContext: "additionalLLMContext" }
-    });
+    return transformScoreRow(row);
   }
   async getScoreById({ id }) {
     const result = await this.#client.execute({
-      sql: `SELECT * FROM ${TABLE_SCORERS} WHERE id = ?`,
+      sql: `SELECT ${buildSelectColumns(TABLE_SCORERS)} FROM ${TABLE_SCORERS} WHERE id = ?`,
       args: [id]
     });
     return result.rows?.[0] ? this.transformScoreRow(result.rows[0]) : null;
@@ -3435,7 +3878,7 @@ var ScoresLibSQL = class extends ScoresStorage {
       const limitValue = perPageInput === false ? total : perPage;
       const end = perPageInput === false ? total : start + perPage;
       const result = await this.#client.execute({
-        sql: `SELECT * FROM ${TABLE_SCORERS} WHERE entityId = ? AND entityType = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        sql: `SELECT ${buildSelectColumns(TABLE_SCORERS)} FROM ${TABLE_SCORERS} WHERE entityId = ? AND entityType = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
         args: [entityId, entityType, limitValue, start]
       });
       const scores = result.rows?.map((row) => this.transformScoreRow(row)) ?? [];
@@ -3476,7 +3919,7 @@ var ScoresLibSQL = class extends ScoresStorage {
       const limitValue = perPageInput === false ? total : perPage;
       const end = perPageInput === false ? total : start + perPage;
       const result = await this.#client.execute({
-        sql: `SELECT * FROM ${TABLE_SCORERS} WHERE traceId = ? AND spanId = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        sql: `SELECT ${buildSelectColumns(TABLE_SCORERS)} FROM ${TABLE_SCORERS} WHERE traceId = ? AND spanId = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
         args: [traceId, spanId, limitValue, start]
       });
       const scores = result.rows?.map((row) => this.transformScoreRow(row)) ?? [];
@@ -3501,24 +3944,6 @@ var ScoresLibSQL = class extends ScoresStorage {
     }
   }
 };
-function parseWorkflowRun(row) {
-  let parsedSnapshot = row.snapshot;
-  if (typeof parsedSnapshot === "string") {
-    try {
-      parsedSnapshot = JSON.parse(row.snapshot);
-    } catch (e) {
-      console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
-    }
-  }
-  return {
-    workflowName: row.workflow_name,
-    runId: row.run_id,
-    snapshot: parsedSnapshot,
-    resourceId: row.resourceId,
-    createdAt: new Date(row.createdAt),
-    updatedAt: new Date(row.updatedAt)
-  };
-}
 var WorkflowsLibSQL = class extends WorkflowsStorage {
   #db;
   #client;
@@ -3539,6 +3964,24 @@ var WorkflowsLibSQL = class extends WorkflowsStorage {
       (err) => this.logger.warn("LibSQL Workflows: Failed to setup PRAGMA settings.", err)
     );
   }
+  parseWorkflowRun(row) {
+    let parsedSnapshot = row.snapshot;
+    if (typeof parsedSnapshot === "string") {
+      try {
+        parsedSnapshot = JSON.parse(row.snapshot);
+      } catch (e) {
+        this.logger.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+      }
+    }
+    return {
+      workflowName: row.workflow_name,
+      runId: row.run_id,
+      snapshot: parsedSnapshot,
+      resourceId: row.resourceId,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    };
+  }
   async init() {
     const schema = TABLE_SCHEMAS[TABLE_WORKFLOW_SNAPSHOT];
     await this.#db.createTable({ tableName: TABLE_WORKFLOW_SNAPSHOT, schema });
@@ -3582,7 +4025,7 @@ var WorkflowsLibSQL = class extends WorkflowsStorage {
       const tx = await this.#client.transaction("write");
       try {
         const existingSnapshotResult = await tx.execute({
-          sql: `SELECT snapshot FROM ${TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
+          sql: `SELECT json(snapshot) as snapshot FROM ${TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
           args: [workflowName, runId]
         });
         let snapshot;
@@ -3607,9 +4050,13 @@ var WorkflowsLibSQL = class extends WorkflowsStorage {
         }
         snapshot.context[stepId] = result;
         snapshot.requestContext = { ...snapshot.requestContext, ...requestContext };
+        const now = (/* @__PURE__ */ new Date()).toISOString();
         await tx.execute({
-          sql: `UPDATE ${TABLE_WORKFLOW_SNAPSHOT} SET snapshot = ? WHERE workflow_name = ? AND run_id = ?`,
-          args: [JSON.stringify(snapshot), workflowName, runId]
+          sql: `INSERT INTO ${TABLE_WORKFLOW_SNAPSHOT} (workflow_name, run_id, snapshot, createdAt, updatedAt)
+                VALUES (?, ?, jsonb(?), ?, ?)
+                ON CONFLICT(workflow_name, run_id)
+                DO UPDATE SET snapshot = excluded.snapshot, updatedAt = excluded.updatedAt`,
+          args: [workflowName, runId, JSON.stringify(snapshot), now, now]
         });
         await tx.commit();
         return snapshot.context;
@@ -3630,7 +4077,7 @@ var WorkflowsLibSQL = class extends WorkflowsStorage {
       const tx = await this.#client.transaction("write");
       try {
         const existingSnapshotResult = await tx.execute({
-          sql: `SELECT snapshot FROM ${TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
+          sql: `SELECT json(snapshot) as snapshot FROM ${TABLE_WORKFLOW_SNAPSHOT} WHERE workflow_name = ? AND run_id = ?`,
           args: [workflowName, runId]
         });
         if (!existingSnapshotResult.rows?.[0]) {
@@ -3645,7 +4092,7 @@ var WorkflowsLibSQL = class extends WorkflowsStorage {
         }
         const updatedSnapshot = { ...snapshot, ...opts };
         await tx.execute({
-          sql: `UPDATE ${TABLE_WORKFLOW_SNAPSHOT} SET snapshot = ? WHERE workflow_name = ? AND run_id = ?`,
+          sql: `UPDATE ${TABLE_WORKFLOW_SNAPSHOT} SET snapshot = jsonb(?) WHERE workflow_name = ? AND run_id = ?`,
           args: [JSON.stringify(updatedSnapshot), workflowName, runId]
         });
         await tx.commit();
@@ -3709,13 +4156,13 @@ var WorkflowsLibSQL = class extends WorkflowsStorage {
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
     try {
       const result = await this.#client.execute({
-        sql: `SELECT * FROM ${TABLE_WORKFLOW_SNAPSHOT} ${whereClause} ORDER BY createdAt DESC LIMIT 1`,
+        sql: `SELECT workflow_name, run_id, resourceId, json(snapshot) as snapshot, createdAt, updatedAt FROM ${TABLE_WORKFLOW_SNAPSHOT} ${whereClause} ORDER BY createdAt DESC LIMIT 1`,
         args
       });
       if (!result.rows?.[0]) {
         return null;
       }
-      return parseWorkflowRun(result.rows[0]);
+      return this.parseWorkflowRun(result.rows[0]);
     } catch (error) {
       throw new MastraError(
         {
@@ -3781,7 +4228,7 @@ var WorkflowsLibSQL = class extends WorkflowsStorage {
           conditions.push("resourceId = ?");
           args.push(resourceId);
         } else {
-          console.warn(`[${TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
+          this.logger.warn(`[${TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
         }
       }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
@@ -3797,10 +4244,10 @@ var WorkflowsLibSQL = class extends WorkflowsStorage {
       const normalizedPerPage = usePagination ? normalizePerPage(perPage, Number.MAX_SAFE_INTEGER) : 0;
       const offset = usePagination ? page * normalizedPerPage : 0;
       const result = await this.#client.execute({
-        sql: `SELECT * FROM ${TABLE_WORKFLOW_SNAPSHOT} ${whereClause} ORDER BY createdAt DESC${usePagination ? ` LIMIT ? OFFSET ?` : ""}`,
+        sql: `SELECT workflow_name, run_id, resourceId, json(snapshot) as snapshot, createdAt, updatedAt FROM ${TABLE_WORKFLOW_SNAPSHOT} ${whereClause} ORDER BY createdAt DESC${usePagination ? ` LIMIT ? OFFSET ?` : ""}`,
         args: usePagination ? [...args, normalizedPerPage, offset] : args
       });
-      const runs = (result.rows || []).map((row) => parseWorkflowRun(row));
+      const runs = (result.rows || []).map((row) => this.parseWorkflowRun(row));
       return { runs, total: total || runs.length };
     } catch (error) {
       throw new MastraError(
@@ -3816,7 +4263,7 @@ var WorkflowsLibSQL = class extends WorkflowsStorage {
 };
 
 // src/storage/index.ts
-var LibSQLStore = class extends MastraStorage {
+var LibSQLStore = class extends MastraCompositeStore {
   client;
   maxRetries;
   initialBackoffMs;
@@ -3861,19 +4308,6 @@ var LibSQLStore = class extends MastraStorage {
       agents
     };
   }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true,
-      hasColumn: true,
-      createTable: true,
-      deleteMessages: true,
-      observability: true,
-      indexManagement: false,
-      listScoresBySpan: true,
-      agents: true
-    };
-  }
 };
 
 // src/vector/prompt.ts
@@ -3975,6 +4409,6 @@ Example Complex Query:
   ]
 }`;
 
-export { LibSQLStore as DefaultStorage, LIBSQL_PROMPT, LibSQLStore, LibSQLVector };
+export { AgentsLibSQL, LibSQLStore as DefaultStorage, LIBSQL_PROMPT, LibSQLStore, LibSQLVector, MemoryLibSQL, ObservabilityLibSQL, ScoresLibSQL, WorkflowsLibSQL };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map