@mastra/libsql 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/index.js

@@ -3,7 +3,7 @@ import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { parseSqlIdentifier, parseFieldKey } from '@mastra/core/utils';
 import { MastraVector } from '@mastra/core/vector';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
-import { MastraStorage, StoreOperations, TABLE_WORKFLOW_SNAPSHOT, TABLE_SPANS, ScoresStorage, TABLE_SCORERS, normalizePerPage, calculatePagination, safelyParseJSON, WorkflowsStorage, MemoryStorage, TABLE_MESSAGES, TABLE_THREADS, TABLE_RESOURCES, ObservabilityStorage, TABLE_SCHEMAS, SPAN_SCHEMA } from '@mastra/core/storage';
+import { MastraStorage, StoreOperations, TABLE_WORKFLOW_SNAPSHOT, TABLE_SPANS, ScoresStorage, TABLE_SCORERS, normalizePerPage, calculatePagination, transformScoreRow, WorkflowsStorage, MemoryStorage, TABLE_MESSAGES, TABLE_THREADS, TABLE_RESOURCES, ObservabilityStorage, TABLE_SCHEMAS, safelyParseJSON, SPAN_SCHEMA } from '@mastra/core/storage';
 import { MessageList } from '@mastra/core/agent';
 import { saveScorePayloadSchema } from '@mastra/core/evals';
 
@@ -90,12 +90,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) => {
@@ -824,8 +832,27 @@ var LibSQLVector = class extends MastraVector {
   updateVector(args) {
     return this.executeWriteOperationWithRetry(() => this.doUpdateVector(args));
   }
-  async doUpdateVector({ indexName, id, update }) {
+  async doUpdateVector(params) {
+    const { indexName, update } = params;
     const parsedIndexName = parseSqlIdentifier(indexName, "index name");
+    if ("id" in params && params.id && "filter" in params && params.filter) {
+      throw new MastraError({
+        id: "LIBSQL_VECTOR_UPDATE_MUTUALLY_EXCLUSIVE_PARAMS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        details: { indexName },
+        text: "id and filter are mutually exclusive - provide only one"
+      });
+    }
+    if (!update.vector && !update.metadata) {
+      throw new MastraError({
+        id: "LIBSQL_VECTOR_UPDATE_VECTOR_INVALID_ARGS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        details: { indexName },
+        text: "No updates provided"
+      });
+    }
     const updates = [];
     const args = [];
     if (update.vector) {
@@ -837,32 +864,81 @@ var LibSQLVector = class extends 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 MastraError({
+          id: "LIBSQL_VECTOR_UPDATE_EMPTY_FILTER",
+          domain: ErrorDomain.STORAGE,
+          category: 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 MastraError({
+          id: "LIBSQL_VECTOR_UPDATE_INVALID_FILTER",
+          domain: ErrorDomain.STORAGE,
+          category: 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 MastraError({
+          id: "LIBSQL_VECTOR_UPDATE_MATCH_ALL_FILTER",
+          domain: ErrorDomain.STORAGE,
+          category: 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 MastraError({
-        id: "LIBSQL_VECTOR_UPDATE_VECTOR_INVALID_ARGS",
+        id: "LIBSQL_VECTOR_UPDATE_MISSING_PARAMS",
         domain: ErrorDomain.STORAGE,
         category: 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) {
+      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 MastraError(
         {
           id: "LIBSQL_VECTOR_UPDATE_VECTOR_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { indexName, id }
+          details: errorDetails
         },
         error
       );
@@ -884,7 +960,10 @@ var LibSQLVector = class extends MastraVector {
           id: "LIBSQL_VECTOR_DELETE_VECTOR_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { indexName: args.indexName, id: args.id }
+          details: {
+            indexName: args.indexName,
+            ...args.id && { id: args.id }
+          }
         },
         error
       );
@@ -897,6 +976,100 @@ var LibSQLVector = class extends MastraVector {
       args: [id]
     });
   }
+  deleteVectors(args) {
+    return this.executeWriteOperationWithRetry(() => this.doDeleteVectors(args));
+  }
+  async doDeleteVectors({ indexName, filter, ids }) {
+    const parsedIndexName = parseSqlIdentifier(indexName, "index name");
+    if (!filter && !ids) {
+      throw new MastraError({
+        id: "LIBSQL_VECTOR_DELETE_MISSING_PARAMS",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        details: { indexName },
+        text: "Either filter or ids must be provided"
+      });
+    }
+    if (filter && ids) {
+      throw new MastraError({
+        id: "LIBSQL_VECTOR_DELETE_CONFLICTING_PARAMS",
+        domain: ErrorDomain.STORAGE,
+        category: 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 MastraError({
+          id: "LIBSQL_VECTOR_DELETE_EMPTY_IDS",
+          domain: ErrorDomain.STORAGE,
+          category: 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 MastraError({
+          id: "LIBSQL_VECTOR_DELETE_EMPTY_FILTER",
+          domain: ErrorDomain.STORAGE,
+          category: 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 MastraError({
+          id: "LIBSQL_VECTOR_DELETE_INVALID_FILTER",
+          domain: ErrorDomain.STORAGE,
+          category: 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 MastraError({
+          id: "LIBSQL_VECTOR_DELETE_MATCH_ALL_FILTER",
+          domain: ErrorDomain.STORAGE,
+          category: 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) {
+      throw new MastraError(
+        {
+          id: "LIBSQL_VECTOR_DELETE_VECTORS_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName,
+            ...filter && { filter: JSON.stringify(filter) },
+            ...ids && { idsCount: ids.length }
+          }
+        },
+        error
+      );
+    }
+  }
   truncateIndex(args) {
     try {
       return this.executeWriteOperationWithRetry(() => this._doTruncateIndex(args));
@@ -944,26 +1117,24 @@ var MemoryLibSQL = class extends MemoryStorage {
     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;
+  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;
-      const searchId = inc.threadId || threadId;
       unionQueries.push(
         `
                 SELECT * FROM (
-                  WITH numbered_messages AS (
+                  WITH target_thread AS (
+                    SELECT thread_id FROM "${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 "${TABLE_MESSAGES}"
-                    WHERE thread_id = ?
+                    WHERE thread_id = (SELECT thread_id FROM target_thread)
                   ),
                   target_positions AS (
                     SELECT row_num as target_pos
@@ -978,7 +1149,7 @@ var MemoryLibSQL = class extends MemoryStorage {
                 `
         // Keep ASC for final sorting after fetching context
       );
-      params.push(searchId, id, withPreviousMessages, withNextMessages);
+      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 });
@@ -1025,15 +1196,16 @@ var MemoryLibSQL = class extends MemoryStorage {
   }
   async listMessages(args) {
     const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
-    if (!threadId.trim()) {
+    const threadIds = Array.isArray(threadId) ? threadId : [threadId];
+    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
       throw new MastraError(
         {
           id: "STORAGE_LIBSQL_LIST_MESSAGES_INVALID_THREAD_ID",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: { threadId: Array.isArray(threadId) ? threadId.join(",") : threadId }
         },
-        new Error("threadId must be a non-empty string")
+        new Error("threadId must be a non-empty string or array of non-empty strings")
       );
     }
     if (page < 0) {
@@ -1052,8 +1224,9 @@ var MemoryLibSQL = class extends MemoryStorage {
     try {
       const { field, direction } = this.parseOrderBy(orderBy, "ASC");
       const orderByStatement = `ORDER BY "${field}" ${direction}`;
-      const conditions = [`thread_id = ?`];
-      const queryParams = [threadId];
+      const threadPlaceholders = threadIds.map(() => "?").join(", ");
+      const conditions = [`thread_id IN (${threadPlaceholders})`];
+      const queryParams = [...threadIds];
       if (resourceId) {
         conditions.push(`"resourceId" = ?`);
         queryParams.push(resourceId);
@@ -1093,7 +1266,7 @@ var MemoryLibSQL = class extends MemoryStorage {
       }
       const messageIds = new Set(messages.map((m) => m.id));
       if (include && include.length > 0) {
-        const includeMessages = await this._getIncludedMessages({ threadId, include });
+        const includeMessages = await this._getIncludedMessages({ include });
         if (includeMessages) {
           for (const includeMsg of includeMessages) {
             if (!messageIds.has(includeMsg.id)) {
@@ -1114,7 +1287,10 @@ var MemoryLibSQL = class extends MemoryStorage {
         }
         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 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 {
@@ -1131,7 +1307,7 @@ var MemoryLibSQL = class extends MemoryStorage {
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
-            threadId,
+            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
             resourceId: resourceId ?? ""
           }
         },
@@ -2550,45 +2726,14 @@ var ScoresLibSQL = class extends ScoresStorage {
       );
     }
   }
+  /**
+   * LibSQL-specific score row transformation.
+   * Maps additionalLLMContext column to additionalContext field.
+   */
   transformScoreRow(row) {
-    const scorerValue = safelyParseJSON(row.scorer);
-    const inputValue = safelyParseJSON(row.input ?? "{}");
-    const outputValue = safelyParseJSON(row.output ?? "{}");
-    const additionalLLMContextValue = row.additionalLLMContext ? safelyParseJSON(row.additionalLLMContext) : null;
-    const requestContextValue = row.requestContext ? safelyParseJSON(row.requestContext) : null;
-    const metadataValue = row.metadata ? safelyParseJSON(row.metadata) : null;
-    const entityValue = row.entity ? safelyParseJSON(row.entity) : null;
-    const preprocessStepResultValue = row.preprocessStepResult ? safelyParseJSON(row.preprocessStepResult) : null;
-    const analyzeStepResultValue = row.analyzeStepResult ? 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 transformScoreRow(row, {
+      fieldMappings: { additionalContext: "additionalLLMContext" }
+    });
   }
   async getScoreById({ id }) {
     const result = await this.client.execute({