@mastra/core 0.2.0-alpha.99 → 0.2.0

package/dist/chunk-SDBM53G4.js

@@ -0,0 +1,32 @@
+import { InstrumentClass } from './chunk-FGZVE4CM.js';
+import { MastraBase } from './chunk-AWEACB2T.js';
+import { __decoratorStart, __decorateElement, __runInitializers } from './chunk-C6A6W6XS.js';
+
+// src/tts/index.ts
+var _MastraTTS_decorators, _init, _a;
+_MastraTTS_decorators = [InstrumentClass({
+  prefix: "tts",
+  excludeMethods: ["__setTools", "__setLogger", "__setTelemetry", "#log"]
+})];
+var MastraTTS = class extends (_a = MastraBase) {
+  model;
+  constructor({ model }) {
+    super({
+      component: "TTS"
+    });
+    this.model = model;
+  }
+  traced(method, methodName) {
+    return this.telemetry?.traceMethod(method, {
+      spanName: `${this.model.name}-tts.${methodName}`,
+      attributes: {
+        "tts.type": `${this.model.name}`
+      }
+    }) ?? method;
+  }
+};
+_init = __decoratorStart(_a);
+MastraTTS = __decorateElement(_init, 0, "MastraTTS", _MastraTTS_decorators, MastraTTS);
+__runInitializers(_init, 1, MastraTTS);
+
+export { MastraTTS };

package/dist/{chunk-4LJFWC2Q.js → chunk-SIFBBGY6.js}

@@ -1,31 +1,42 @@
-import { __name, __publicField } from './chunk-AJJZUHB4.js';
-
 // src/filter/base.ts
-var _a;
-var BaseFilterTranslator = (_a = class {
+var BaseFilterTranslator = class _BaseFilterTranslator {
   /**
-  * Operator type checks
-  */
+   * Operator type checks
+   */
   isOperator(key) {
     return key.startsWith("$");
   }
+  static BASIC_OPERATORS = ["$eq", "$ne"];
+  static NUMERIC_OPERATORS = ["$gt", "$gte", "$lt", "$lte"];
+  static ARRAY_OPERATORS = ["$in", "$nin", "$all", "$elemMatch"];
+  static LOGICAL_OPERATORS = ["$and", "$or", "$not", "$nor"];
+  static ELEMENT_OPERATORS = ["$exists"];
+  static REGEX_OPERATORS = ["$regex", "$options"];
+  static DEFAULT_OPERATORS = {
+    logical: _BaseFilterTranslator.LOGICAL_OPERATORS,
+    basic: _BaseFilterTranslator.BASIC_OPERATORS,
+    numeric: _BaseFilterTranslator.NUMERIC_OPERATORS,
+    array: _BaseFilterTranslator.ARRAY_OPERATORS,
+    element: _BaseFilterTranslator.ELEMENT_OPERATORS,
+    regex: _BaseFilterTranslator.REGEX_OPERATORS
+  };
   isLogicalOperator(key) {
-    return _a.DEFAULT_OPERATORS.logical.includes(key);
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.logical.includes(key);
   }
   isBasicOperator(key) {
-    return _a.DEFAULT_OPERATORS.basic.includes(key);
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.basic.includes(key);
   }
   isNumericOperator(key) {
-    return _a.DEFAULT_OPERATORS.numeric.includes(key);
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.numeric.includes(key);
   }
   isArrayOperator(key) {
-    return _a.DEFAULT_OPERATORS.array.includes(key);
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.array.includes(key);
   }
   isElementOperator(key) {
-    return _a.DEFAULT_OPERATORS.element.includes(key);
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.element.includes(key);
   }
   isRegexOperator(key) {
-    return _a.DEFAULT_OPERATORS.regex.includes(key);
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.regex.includes(key);
   }
   isFieldOperator(key) {
     return this.isOperator(key) && !this.isLogicalOperator(key);
@@ -35,7 +46,7 @@ var BaseFilterTranslator = (_a = class {
     return support.custom?.includes(key) ?? false;
   }
   getSupportedOperators() {
-    return _a.DEFAULT_OPERATORS;
+    return _BaseFilterTranslator.DEFAULT_OPERATORS;
   }
   isValidOperator(key) {
     const support = this.getSupportedOperators();
@@ -43,8 +54,8 @@ var BaseFilterTranslator = (_a = class {
     return allSupported.includes(key);
   }
   /**
-  * Value normalization for comparison operators
-  */
+   * Value normalization for comparison operators
+   */
   normalizeComparisonValue(value) {
     if (value instanceof Date) {
       return value.toISOString();
@@ -55,23 +66,19 @@ var BaseFilterTranslator = (_a = class {
     return value;
   }
   /**
-  * Helper method to simulate $all operator using $and + $eq when needed.
-  * Some vector stores don't support $all natively.
-  */
+   * Helper method to simulate $all operator using $and + $eq when needed.
+   * Some vector stores don't support $all natively.
+   */
   simulateAllOperator(field, values) {
     return {
       $and: values.map((value) => ({
-        [field]: {
-          $in: [
-            this.normalizeComparisonValue(value)
-          ]
-        }
+        [field]: { $in: [this.normalizeComparisonValue(value)] }
       }))
     };
   }
   /**
-  * Utility functions for type checking
-  */
+   * Utility functions for type checking
+   */
   isPrimitive(value) {
     return value === null || value === undefined || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
   }
@@ -81,9 +88,18 @@ var BaseFilterTranslator = (_a = class {
   isEmpty(obj) {
     return obj === null || obj === undefined || typeof obj === "object" && Object.keys(obj).length === 0;
   }
+  static ErrorMessages = {
+    UNSUPPORTED_OPERATOR: (op) => `Unsupported operator: ${op}`,
+    INVALID_LOGICAL_OPERATOR_LOCATION: (op, path) => `Logical operator ${op} cannot be used at field level: ${path}`,
+    NOT_REQUIRES_OBJECT: `$not operator requires an object`,
+    NOT_CANNOT_BE_EMPTY: `$not operator cannot be empty`,
+    INVALID_LOGICAL_OPERATOR_CONTENT: (path) => `Logical operators must contain field conditions, not direct operators: ${path}`,
+    INVALID_TOP_LEVEL_OPERATOR: (op) => `Invalid top-level operator: ${op}`,
+    ELEM_MATCH_REQUIRES_OBJECT: `$elemMatch requires an object with conditions`
+  };
   /**
-  * Helper to handle array value normalization consistently
-  */
+   * Helper to handle array value normalization consistently
+   */
   normalizeArrayValues(values) {
     return values.map((value) => this.normalizeComparisonValue(value));
   }
@@ -94,16 +110,13 @@ var BaseFilterTranslator = (_a = class {
     }
   }
   /**
-  * Validates if a filter structure is supported by the specific vector DB
-  * and returns detailed validation information.
-  */
+   * Validates if a filter structure is supported by the specific vector DB
+   * and returns detailed validation information.
+   */
   validateFilterSupport(node, path = "") {
     const messages = [];
     if (this.isPrimitive(node) || this.isEmpty(node)) {
-      return {
-        supported: true,
-        messages: []
-      };
+      return { supported: true, messages: [] };
     }
     if (Array.isArray(node)) {
       const arrayResults = node.map((item) => this.validateFilterSupport(item, path));
@@ -120,43 +133,45 @@ var BaseFilterTranslator = (_a = class {
       if (this.isOperator(key)) {
         if (!this.isValidOperator(key)) {
           isSupported = false;
-          messages.push(_a.ErrorMessages.UNSUPPORTED_OPERATOR(key));
+          messages.push(_BaseFilterTranslator.ErrorMessages.UNSUPPORTED_OPERATOR(key));
           continue;
         }
         if (!path && !this.isLogicalOperator(key)) {
           isSupported = false;
-          messages.push(_a.ErrorMessages.INVALID_TOP_LEVEL_OPERATOR(key));
+          messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_TOP_LEVEL_OPERATOR(key));
           continue;
         }
         if (key === "$elemMatch" && (typeof value !== "object" || Array.isArray(value))) {
           isSupported = false;
-          messages.push(_a.ErrorMessages.ELEM_MATCH_REQUIRES_OBJECT);
+          messages.push(_BaseFilterTranslator.ErrorMessages.ELEM_MATCH_REQUIRES_OBJECT);
           continue;
         }
         if (this.isLogicalOperator(key)) {
           if (key === "$not") {
             if (Array.isArray(value) || typeof value !== "object") {
               isSupported = false;
-              messages.push(_a.ErrorMessages.NOT_REQUIRES_OBJECT);
+              messages.push(_BaseFilterTranslator.ErrorMessages.NOT_REQUIRES_OBJECT);
               continue;
             }
             if (this.isEmpty(value)) {
               isSupported = false;
-              messages.push(_a.ErrorMessages.NOT_CANNOT_BE_EMPTY);
+              messages.push(_BaseFilterTranslator.ErrorMessages.NOT_CANNOT_BE_EMPTY);
               continue;
             }
             continue;
           }
           if (path && !this.isLogicalOperator(path.split(".").pop())) {
             isSupported = false;
-            messages.push(_a.ErrorMessages.INVALID_LOGICAL_OPERATOR_LOCATION(key, newPath));
+            messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_LOGICAL_OPERATOR_LOCATION(key, newPath));
             continue;
           }
           if (Array.isArray(value)) {
-            const hasDirectOperators = value.some((item) => typeof item === "object" && Object.keys(item).length === 1 && this.isFieldOperator(Object.keys(item)[0]));
+            const hasDirectOperators = value.some(
+              (item) => typeof item === "object" && Object.keys(item).length === 1 && this.isFieldOperator(Object.keys(item)[0])
+            );
             if (hasDirectOperators) {
               isSupported = false;
-              messages.push(_a.ErrorMessages.INVALID_LOGICAL_OPERATOR_CONTENT(newPath));
+              messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_LOGICAL_OPERATOR_CONTENT(newPath));
               continue;
             }
           }
@@ -168,49 +183,8 @@ var BaseFilterTranslator = (_a = class {
         messages.push(...nestedValidation.messages);
       }
     }
-    return {
-      supported: isSupported,
-      messages
-    };
+    return { supported: isSupported, messages };
   }
-}, __name(_a, "BaseFilterTranslator"), __publicField(_a, "BASIC_OPERATORS", [
-  "$eq",
-  "$ne"
-]), __publicField(_a, "NUMERIC_OPERATORS", [
-  "$gt",
-  "$gte",
-  "$lt",
-  "$lte"
-]), __publicField(_a, "ARRAY_OPERATORS", [
-  "$in",
-  "$nin",
-  "$all",
-  "$elemMatch"
-]), __publicField(_a, "LOGICAL_OPERATORS", [
-  "$and",
-  "$or",
-  "$not",
-  "$nor"
-]), __publicField(_a, "ELEMENT_OPERATORS", [
-  "$exists"
-]), __publicField(_a, "REGEX_OPERATORS", [
-  "$regex",
-  "$options"
-]), __publicField(_a, "DEFAULT_OPERATORS", {
-  logical: _a.LOGICAL_OPERATORS,
-  basic: _a.BASIC_OPERATORS,
-  numeric: _a.NUMERIC_OPERATORS,
-  array: _a.ARRAY_OPERATORS,
-  element: _a.ELEMENT_OPERATORS,
-  regex: _a.REGEX_OPERATORS
-}), __publicField(_a, "ErrorMessages", {
-  UNSUPPORTED_OPERATOR: /* @__PURE__ */ __name((op) => `Unsupported operator: ${op}`, "UNSUPPORTED_OPERATOR"),
-  INVALID_LOGICAL_OPERATOR_LOCATION: /* @__PURE__ */ __name((op, path) => `Logical operator ${op} cannot be used at field level: ${path}`, "INVALID_LOGICAL_OPERATOR_LOCATION"),
-  NOT_REQUIRES_OBJECT: `$not operator requires an object`,
-  NOT_CANNOT_BE_EMPTY: `$not operator cannot be empty`,
-  INVALID_LOGICAL_OPERATOR_CONTENT: /* @__PURE__ */ __name((path) => `Logical operators must contain field conditions, not direct operators: ${path}`, "INVALID_LOGICAL_OPERATOR_CONTENT"),
-  INVALID_TOP_LEVEL_OPERATOR: /* @__PURE__ */ __name((op) => `Invalid top-level operator: ${op}`, "INVALID_TOP_LEVEL_OPERATOR"),
-  ELEM_MATCH_REQUIRES_OBJECT: `$elemMatch requires an object with conditions`
-}), _a);
+};
 
 export { BaseFilterTranslator };