@mastra/core 0.2.0-alpha.98 → 0.2.0

package/dist/{chunk-ZJOMHCWE.js → chunk-OJ26F3J4.js}

@@ -1,19 +1,15 @@
-import { MastraVector } from './chunk-C55JWGDU.js';
-import { BaseFilterTranslator } from './chunk-4LJFWC2Q.js';
-import { __name, __publicField } from './chunk-AJJZUHB4.js';
+import { MastraVector } from './chunk-ZJOXJFJI.js';
+import { BaseFilterTranslator } from './chunk-SIFBBGY6.js';
 import { createClient } from '@libsql/client';
 import { join } from 'path';
 
 // src/vector/libsql/filter.ts
-var _LibSQLFilterTranslator = class _LibSQLFilterTranslator extends BaseFilterTranslator {
+var LibSQLFilterTranslator = class extends BaseFilterTranslator {
   getSupportedOperators() {
     return {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
       regex: [],
-      custom: [
-        "$contains",
-        "$size"
-      ]
+      custom: ["$contains", "$size"]
     };
   }
   translate(filter) {
@@ -27,18 +23,12 @@ var _LibSQLFilterTranslator = class _LibSQLFilterTranslator extends BaseFilterTr
     if (this.isRegex(node)) {
       throw new Error("Direct regex pattern format is not supported in LibSQL");
     }
-    const withPath = /* @__PURE__ */ __name((result2) => currentPath ? {
-      [currentPath]: result2
-    } : result2, "withPath");
+    const withPath = (result2) => currentPath ? { [currentPath]: result2 } : result2;
     if (this.isPrimitive(node)) {
-      return withPath({
-        $eq: this.normalizeComparisonValue(node)
-      });
+      return withPath({ $eq: this.normalizeComparisonValue(node) });
     }
     if (Array.isArray(node)) {
-      return withPath({
-        $in: this.normalizeArrayValues(node)
-      });
+      return withPath({ $in: this.normalizeArrayValues(node) });
     }
     const entries = Object.entries(node);
     const result = {};
@@ -48,9 +38,7 @@ var _LibSQLFilterTranslator = class _LibSQLFilterTranslator extends BaseFilterTr
         result[key] = Array.isArray(value) ? value.map((filter) => this.translateNode(filter)) : this.translateNode(value);
       } else if (this.isOperator(key)) {
         if (this.isArrayOperator(key) && !Array.isArray(value) && key !== "$elemMatch") {
-          result[key] = [
-            value
-          ];
+          result[key] = [value];
         } else if (this.isBasicOperator(key) && Array.isArray(value)) {
           result[key] = JSON.stringify(value);
         } else {
@@ -69,34 +57,39 @@ var _LibSQLFilterTranslator = class _LibSQLFilterTranslator extends BaseFilterTr
     }
     return result;
   }
+  // TODO: Look more into regex support for LibSQL
+  // private translateRegexPattern(pattern: string, options: string = ''): any {
+  //   if (!options) return { $regex: pattern };
+  //   const flags = options
+  //     .split('')
+  //     .filter(f => 'imsux'.includes(f))
+  //     .join('');
+  //   return {
+  //     $regex: pattern,
+  //     $options: flags,
+  //   };
+  // }
 };
-__name(_LibSQLFilterTranslator, "LibSQLFilterTranslator");
-var LibSQLFilterTranslator = _LibSQLFilterTranslator;
-
-// src/vector/libsql/sql-builder.ts
-var createBasicOperator = /* @__PURE__ */ __name((symbol) => {
+var createBasicOperator = (symbol) => {
   return (key) => ({
     sql: `CASE 
       WHEN ? IS NULL THEN json_extract(metadata, '$."${handleKey(key)}"') IS ${symbol === "=" ? "" : "NOT"} NULL
       ELSE json_extract(metadata, '$."${handleKey(key)}"') ${symbol} ?
     END`,
     needsValue: true,
-    transformValue: /* @__PURE__ */ __name((value) => {
-      return [
-        value,
-        value
-      ];
-    }, "transformValue")
+    transformValue: (value) => {
+      return [value, value];
+    }
   });
-}, "createBasicOperator");
-var createNumericOperator = /* @__PURE__ */ __name((symbol) => {
+};
+var createNumericOperator = (symbol) => {
   return (key) => ({
     sql: `CAST(json_extract(metadata, '$."${handleKey(key)}"') AS NUMERIC) ${symbol} ?`,
     needsValue: true
   });
-}, "createNumericOperator");
-var validateJsonArray = /* @__PURE__ */ __name((key) => `json_valid(json_extract(metadata, '$."${handleKey(key)}"'))
-   AND json_type(json_extract(metadata, '$."${handleKey(key)}"')) = 'array'`, "validateJsonArray");
+};
+var validateJsonArray = (key) => `json_valid(json_extract(metadata, '$."${handleKey(key)}"'))
+   AND json_type(json_extract(metadata, '$."${handleKey(key)}"')) = 'array'`;
 var FILTER_OPERATORS = {
   $eq: createBasicOperator("="),
   $ne: createBasicOperator("!="),
@@ -105,21 +98,19 @@ var FILTER_OPERATORS = {
   $lt: createNumericOperator("<"),
   $lte: createNumericOperator("<="),
   // Array Operators
-  $in: /* @__PURE__ */ __name((key, value) => ({
+  $in: (key, value) => ({
     sql: `json_extract(metadata, '$."${handleKey(key)}"') IN (${value.map(() => "?").join(",")})`,
     needsValue: true
-  }), "$in"),
-  $nin: /* @__PURE__ */ __name((key, value) => ({
+  }),
+  $nin: (key, value) => ({
     sql: `json_extract(metadata, '$."${handleKey(key)}"') NOT IN (${value.map(() => "?").join(",")})`,
     needsValue: true
-  }), "$nin"),
-  $all: /* @__PURE__ */ __name((key) => ({
+  }),
+  $all: (key) => ({
     sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
     needsValue: true,
-    transformValue: /* @__PURE__ */ __name((value) => {
-      const arrayValue = Array.isArray(value) ? value : [
-        value
-      ];
+    transformValue: (value) => {
+      const arrayValue = Array.isArray(value) ? value : [value];
       if (arrayValue.length === 0) {
         return {
           sql: "1 = 0",
@@ -141,44 +132,32 @@ var FILTER_OPERATORS = {
             ELSE FALSE
           END
         )`,
-        values: [
-          JSON.stringify(arrayValue)
-        ]
+        values: [JSON.stringify(arrayValue)]
       };
-    }, "transformValue")
-  }), "$all"),
-  $elemMatch: /* @__PURE__ */ __name((key) => ({
+    }
+  }),
+  $elemMatch: (key) => ({
     sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
     needsValue: true,
-    transformValue: /* @__PURE__ */ __name((value) => {
+    transformValue: (value) => {
       if (typeof value !== "object" || Array.isArray(value)) {
         throw new Error("$elemMatch requires an object with conditions");
       }
       const conditions = Object.entries(value).map(([field, fieldValue]) => {
         if (field.startsWith("$")) {
-          const { sql, values } = buildCondition("elem.value", {
-            [field]: fieldValue
-          });
+          const { sql, values } = buildCondition("elem.value", { [field]: fieldValue });
           const pattern = /json_extract\(metadata, '\$\."[^"]*"(\."[^"]*")*'\)/g;
           const elemSql = sql.replace(pattern, "elem.value");
-          return {
-            sql: elemSql,
-            values
-          };
+          return { sql: elemSql, values };
         } else if (typeof fieldValue === "object" && !Array.isArray(fieldValue)) {
           const { sql, values } = buildCondition(field, fieldValue);
           const pattern = /json_extract\(metadata, '\$\."[^"]*"(\."[^"]*")*'\)/g;
           const elemSql = sql.replace(pattern, `json_extract(elem.value, '$."${field}"')`);
-          return {
-            sql: elemSql,
-            values
-          };
+          return { sql: elemSql, values };
         } else {
           return {
             sql: `json_extract(elem.value, '$."${field}"') = ?`,
-            values: [
-              fieldValue
-            ]
+            values: [fieldValue]
           };
         }
       });
@@ -196,31 +175,28 @@ var FILTER_OPERATORS = {
         )`,
         values: conditions.flatMap((c) => c.values)
       };
-    }, "transformValue")
-  }), "$elemMatch"),
+    }
+  }),
   // Element Operators
-  $exists: /* @__PURE__ */ __name((key) => ({
+  $exists: (key) => ({
     sql: `json_extract(metadata, '$."${handleKey(key)}"') IS NOT NULL`,
     needsValue: false
-  }), "$exists"),
+  }),
   // Logical Operators
-  $and: /* @__PURE__ */ __name((key) => ({
+  $and: (key) => ({
     sql: `(${key})`,
     needsValue: false
-  }), "$and"),
-  $or: /* @__PURE__ */ __name((key) => ({
+  }),
+  $or: (key) => ({
     sql: `(${key})`,
     needsValue: false
-  }), "$or"),
-  $not: /* @__PURE__ */ __name((key) => ({
-    sql: `NOT (${key})`,
-    needsValue: false
-  }), "$not"),
-  $nor: /* @__PURE__ */ __name((key) => ({
+  }),
+  $not: (key) => ({ sql: `NOT (${key})`, needsValue: false }),
+  $nor: (key) => ({
     sql: `NOT (${key})`,
     needsValue: false
-  }), "$nor"),
-  $size: /* @__PURE__ */ __name((key, paramIndex) => ({
+  }),
+  $size: (key, paramIndex) => ({
     sql: `(
     CASE
       WHEN json_type(json_extract(metadata, '$."${handleKey(key)}"')) = 'array' THEN 
@@ -229,7 +205,7 @@ var FILTER_OPERATORS = {
     END
   )`,
     needsValue: true
-  }), "$size"),
+  }),
   //   /**
   //    * Regex Operators
   //    * Supports case insensitive and multiline
@@ -289,10 +265,10 @@ var FILTER_OPERATORS = {
   //       };
   //     },
   //   }),
-  $contains: /* @__PURE__ */ __name((key) => ({
+  $contains: (key) => ({
     sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
     needsValue: true,
-    transformValue: /* @__PURE__ */ __name((value) => {
+    transformValue: (value) => {
       if (Array.isArray(value)) {
         return {
           sql: `(
@@ -303,18 +279,13 @@ var FILTER_OPERATORS = {
               WHERE m.value IN (SELECT value FROM json_each(?))
             )
           )`,
-          values: [
-            JSON.stringify(value)
-          ]
+          values: [JSON.stringify(value)]
         };
       }
       if (value && typeof value === "object") {
         let traverse2 = function(obj, path = []) {
           for (const [k, v] of Object.entries(obj)) {
-            const currentPath = [
-              ...path,
-              k
-            ];
+            const currentPath = [...path, k];
             if (v && typeof v === "object" && !Array.isArray(v)) {
               traverse2(v, currentPath);
             } else {
@@ -323,7 +294,6 @@ var FILTER_OPERATORS = {
             }
           }
         };
-        __name(traverse2, "traverse");
         const paths = [];
         const values = [];
         traverse2(value);
@@ -333,18 +303,15 @@ var FILTER_OPERATORS = {
         };
       }
       return value;
-    }, "transformValue")
-  }), "$contains")
+    }
+  })
 };
-var handleKey = /* @__PURE__ */ __name((key) => {
+var handleKey = (key) => {
   return key.replace(/\./g, '"."');
-}, "handleKey");
+};
 function buildFilterQuery(filter) {
   if (!filter) {
-    return {
-      sql: "",
-      values: []
-    };
+    return { sql: "", values: [] };
   }
   const values = [];
   const conditions = Object.entries(filter).map(([key, value]) => {
@@ -357,48 +324,30 @@ function buildFilterQuery(filter) {
     values
   };
 }
-__name(buildFilterQuery, "buildFilterQuery");
 function buildCondition(key, value, parentPath) {
-  if ([
-    "$and",
-    "$or",
-    "$not",
-    "$nor"
-  ].includes(key)) {
+  if (["$and", "$or", "$not", "$nor"].includes(key)) {
     return handleLogicalOperator(key, value);
   }
   if (!value || typeof value !== "object") {
     return {
       sql: `json_extract(metadata, '$."${key.replace(/\./g, '"."')}"') = ?`,
-      values: [
-        value
-      ]
+      values: [value]
     };
   }
   return handleOperator(key, value);
 }
-__name(buildCondition, "buildCondition");
 function handleLogicalOperator(key, value, parentPath) {
   if (!value || value.length === 0) {
     switch (key) {
       case "$and":
       case "$nor":
-        return {
-          sql: "true",
-          values: []
-        };
+        return { sql: "true", values: [] };
       case "$or":
-        return {
-          sql: "false",
-          values: []
-        };
+        return { sql: "false", values: [] };
       case "$not":
         throw new Error("$not operator cannot be empty");
       default:
-        return {
-          sql: "true",
-          values: []
-        };
+        return { sql: "true", values: [] };
     }
   }
   if (key === "$not") {
@@ -414,9 +363,7 @@ function handleLogicalOperator(key, value, parentPath) {
   const conditions = Array.isArray(value) ? value.map((f) => {
     const entries = Object.entries(f);
     return entries.map(([k, v]) => buildCondition(k, v));
-  }) : [
-    buildCondition(key, value)
-  ];
+  }) : [buildCondition(key, value)];
   const joined = conditions.flat().map((c) => {
     values.push(...c.values);
     return c.sql;
@@ -426,14 +373,17 @@ function handleLogicalOperator(key, value, parentPath) {
     values
   };
 }
-__name(handleLogicalOperator, "handleLogicalOperator");
 function handleOperator(key, value) {
   if (typeof value === "object" && !Array.isArray(value)) {
     const entries = Object.entries(value);
-    const results = entries.map(([operator2, operatorValue2]) => operator2 === "$not" ? {
-      sql: `NOT (${Object.entries(operatorValue2).map(([op, val]) => processOperator(key, op, val).sql).join(" AND ")})`,
-      values: Object.entries(operatorValue2).flatMap(([op, val]) => processOperator(key, op, val).values)
-    } : processOperator(key, operator2, operatorValue2));
+    const results = entries.map(
+      ([operator2, operatorValue2]) => operator2 === "$not" ? {
+        sql: `NOT (${Object.entries(operatorValue2).map(([op, val]) => processOperator(key, op, val).sql).join(" AND ")})`,
+        values: Object.entries(operatorValue2).flatMap(
+          ([op, val]) => processOperator(key, op, val).values
+        )
+      } : processOperator(key, operator2, operatorValue2)
+    );
     return {
       sql: `(${results.map((r) => r.sql).join(" AND ")})`,
       values: results.flatMap((r) => r.values)
@@ -442,18 +392,14 @@ function handleOperator(key, value) {
   const [[operator, operatorValue] = []] = Object.entries(value);
   return processOperator(key, operator, operatorValue);
 }
-__name(handleOperator, "handleOperator");
-var processOperator = /* @__PURE__ */ __name((key, operator, operatorValue) => {
+var processOperator = (key, operator, operatorValue) => {
   if (!operator.startsWith("$") || !FILTER_OPERATORS[operator]) {
     throw new Error(`Invalid operator: ${operator}`);
   }
   const operatorFn = FILTER_OPERATORS[operator];
   const operatorResult = operatorFn(key, operatorValue);
   if (!operatorResult.needsValue) {
-    return {
-      sql: operatorResult.sql,
-      values: []
-    };
+    return { sql: operatorResult.sql, values: [] };
   }
   const transformed = operatorResult.transformValue ? operatorResult.transformValue(operatorValue) : operatorValue;
   if (transformed && typeof transformed === "object" && "sql" in transformed) {
@@ -461,17 +407,20 @@ var processOperator = /* @__PURE__ */ __name((key, operator, operatorValue) => {
   }
   return {
     sql: operatorResult.sql,
-    values: Array.isArray(transformed) ? transformed : [
-      transformed
-    ]
+    values: Array.isArray(transformed) ? transformed : [transformed]
   };
-}, "processOperator");
+};
 
 // src/vector/libsql/index.ts
-var _DefaultVectorDB = class _DefaultVectorDB extends MastraVector {
-  constructor({ connectionUrl, authToken, syncUrl, syncInterval }) {
+var DefaultVectorDB = class extends MastraVector {
+  turso;
+  constructor({
+    connectionUrl,
+    authToken,
+    syncUrl,
+    syncInterval
+  }) {
     super();
-    __publicField(this, "turso");
     this.turso = createClient({
       url: this.rewriteDbUrl(connectionUrl),
       syncUrl,
@@ -486,7 +435,9 @@ var _DefaultVectorDB = class _DefaultVectorDB extends MastraVector {
       if (cwd.endsWith(".mastra") || cwd.endsWith(".mastra/")) {
         const baseDir = join(cwd, `..`);
         const fullPath = join(baseDir, relativePath);
-        this.logger.debug(`Initializing LibSQL db with url ${url} with relative file path from inside .mastra directory. Rewriting relative file url to "file:${fullPath}". This ensures it's outside the .mastra directory. If the db is stored inside .mastra it will be deleted when Mastra re-bundles code.`);
+        this.logger.debug(
+          `Initializing LibSQL db with url ${url} with relative file path from inside .mastra directory. Rewriting relative file url to "file:${fullPath}". This ensures it's outside the .mastra directory. If the db is stored inside .mastra it will be deleted when Mastra re-bundles code.`
+        );
         return `file:${fullPath}`;
       }
     }
@@ -526,9 +477,7 @@ var _DefaultVectorDB = class _DefaultVectorDB extends MastraVector {
         id,
         score,
         metadata: JSON.parse(metadata ?? "{}"),
-        ...includeVector && embedding && {
-          vector: JSON.parse(embedding)
-        }
+        ...includeVector && embedding && { vector: JSON.parse(embedding) }
       }));
     } finally {
     }
@@ -634,9 +583,7 @@ var _DefaultVectorDB = class _DefaultVectorDB extends MastraVector {
       `;
       const tableInfo = await this.turso.execute({
         sql: tableInfoQuery,
-        args: [
-          indexName
-        ]
+        args: [indexName]
       });
       if (!tableInfo.rows[0]?.sql) {
         throw new Error(`Table ${indexName} not found`);
@@ -667,7 +614,5 @@ var _DefaultVectorDB = class _DefaultVectorDB extends MastraVector {
     });
   }
 };
-__name(_DefaultVectorDB, "DefaultVectorDB");
-var DefaultVectorDB = _DefaultVectorDB;
 
 export { DefaultVectorDB };

package/dist/chunk-RG66XEJT.js

@@ -0,0 +1,8 @@
+// src/storage/constants.ts
+var TABLE_WORKFLOW_SNAPSHOT = "mastra_workflow_snapshot";
+var TABLE_EVALS = "mastra_evals";
+var TABLE_MESSAGES = "mastra_messages";
+var TABLE_THREADS = "mastra_threads";
+var TABLE_TRACES = "mastra_traces";
+
+export { TABLE_EVALS, TABLE_MESSAGES, TABLE_THREADS, TABLE_TRACES, TABLE_WORKFLOW_SNAPSHOT };