@mastra/core 0.9.5-alpha.0 → 0.10.0

package/dist/chunk-LGERQTJM.js

@@ -1,190 +0,0 @@
-// src/vector/filter/base.ts
-var BaseFilterTranslator = class _BaseFilterTranslator {
-  /**
-   * 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 _BaseFilterTranslator.DEFAULT_OPERATORS.logical.includes(key);
-  }
-  isBasicOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.basic.includes(key);
-  }
-  isNumericOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.numeric.includes(key);
-  }
-  isArrayOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.array.includes(key);
-  }
-  isElementOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.element.includes(key);
-  }
-  isRegexOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.regex.includes(key);
-  }
-  isFieldOperator(key) {
-    return this.isOperator(key) && !this.isLogicalOperator(key);
-  }
-  isCustomOperator(key) {
-    const support = this.getSupportedOperators();
-    return support.custom?.includes(key) ?? false;
-  }
-  getSupportedOperators() {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS;
-  }
-  isValidOperator(key) {
-    const support = this.getSupportedOperators();
-    const allSupported = Object.values(support).flat();
-    return allSupported.includes(key);
-  }
-  /**
-   * Value normalization for comparison operators
-   */
-  normalizeComparisonValue(value) {
-    if (value instanceof Date) {
-      return value.toISOString();
-    }
-    if (typeof value === "number" && Object.is(value, -0)) {
-      return 0;
-    }
-    return value;
-  }
-  /**
-   * 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)] }
-      }))
-    };
-  }
-  /**
-   * Utility functions for type checking
-   */
-  isPrimitive(value) {
-    return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-  }
-  isRegex(value) {
-    return value instanceof RegExp;
-  }
-  isEmpty(obj) {
-    return obj === null || obj === void 0 || 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
-   */
-  normalizeArrayValues(values) {
-    return values.map((value) => this.normalizeComparisonValue(value));
-  }
-  validateFilter(filter) {
-    const validation = this.validateFilterSupport(filter);
-    if (!validation.supported) {
-      throw new Error(validation.messages.join(", "));
-    }
-  }
-  /**
-   * 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: [] };
-    }
-    if (Array.isArray(node)) {
-      const arrayResults = node.map((item) => this.validateFilterSupport(item, path));
-      const arrayMessages = arrayResults.flatMap((r) => r.messages);
-      return {
-        supported: arrayResults.every((r) => r.supported),
-        messages: arrayMessages
-      };
-    }
-    const nodeObj = node;
-    let isSupported = true;
-    for (const [key, value] of Object.entries(nodeObj)) {
-      const newPath = path ? `${path}.${key}` : key;
-      if (this.isOperator(key)) {
-        if (!this.isValidOperator(key)) {
-          isSupported = false;
-          messages.push(_BaseFilterTranslator.ErrorMessages.UNSUPPORTED_OPERATOR(key));
-          continue;
-        }
-        if (!path && !this.isLogicalOperator(key)) {
-          isSupported = false;
-          messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_TOP_LEVEL_OPERATOR(key));
-          continue;
-        }
-        if (key === "$elemMatch" && (typeof value !== "object" || Array.isArray(value))) {
-          isSupported = false;
-          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(_BaseFilterTranslator.ErrorMessages.NOT_REQUIRES_OBJECT);
-              continue;
-            }
-            if (this.isEmpty(value)) {
-              isSupported = false;
-              messages.push(_BaseFilterTranslator.ErrorMessages.NOT_CANNOT_BE_EMPTY);
-              continue;
-            }
-            continue;
-          }
-          if (path && !this.isLogicalOperator(path.split(".").pop())) {
-            isSupported = false;
-            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])
-            );
-            if (hasDirectOperators) {
-              isSupported = false;
-              messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_LOGICAL_OPERATOR_CONTENT(newPath));
-              continue;
-            }
-          }
-        }
-      }
-      const nestedValidation = this.validateFilterSupport(value, newPath);
-      if (!nestedValidation.supported) {
-        isSupported = false;
-        messages.push(...nestedValidation.messages);
-      }
-    }
-    return { supported: isSupported, messages };
-  }
-};
-
-export { BaseFilterTranslator };

package/dist/chunk-O44MSFMZ.cjs

@@ -1,168 +0,0 @@
-'use strict';
-
-var stream = require('stream');
-var pino = require('pino');
-var pretty = require('pino-pretty');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var pino__default = /*#__PURE__*/_interopDefault(pino);
-var pretty__default = /*#__PURE__*/_interopDefault(pretty);
-
-// src/logger/index.ts
-var RegisteredLogger = {
-  AGENT: "AGENT",
-  NETWORK: "NETWORK",
-  WORKFLOW: "WORKFLOW",
-  LLM: "LLM",
-  TTS: "TTS",
-  VOICE: "VOICE",
-  VECTOR: "VECTOR",
-  BUNDLER: "BUNDLER",
-  DEPLOYER: "DEPLOYER",
-  MEMORY: "MEMORY",
-  STORAGE: "STORAGE",
-  EMBEDDINGS: "EMBEDDINGS",
-  MCP_SERVER: "MCP_SERVER"
-};
-var LogLevel = {
-  DEBUG: "debug",
-  INFO: "info",
-  WARN: "warn",
-  ERROR: "error",
-  NONE: "silent"
-};
-var LoggerTransport = class extends stream.Transform {
-  constructor(opts = {}) {
-    super({ ...opts, objectMode: true });
-  }
-  async getLogsByRunId(_args) {
-    return [];
-  }
-  async getLogs() {
-    return [];
-  }
-};
-var Logger = class {
-  logger;
-  transports;
-  constructor(options = {}) {
-    this.transports = options.transports || {};
-    const transportsAry = Object.entries(this.transports);
-    this.logger = pino__default.default(
-      {
-        name: options.name || "app",
-        level: options.level || LogLevel.INFO,
-        formatters: {
-          level: (label) => {
-            return {
-              level: label
-            };
-          }
-        }
-      },
-      options.overrideDefaultTransports ? options?.transports?.default : transportsAry.length === 0 ? pretty__default.default({
-        colorize: true,
-        levelFirst: true,
-        ignore: "pid,hostname",
-        colorizeObjects: true,
-        translateTime: "SYS:standard",
-        singleLine: false
-      }) : pino__default.default.multistream([
-        ...transportsAry.map(([, transport]) => ({
-          stream: transport,
-          level: options.level || LogLevel.INFO
-        })),
-        {
-          stream: pretty__default.default({
-            colorize: true,
-            levelFirst: true,
-            ignore: "pid,hostname",
-            colorizeObjects: true,
-            translateTime: "SYS:standard",
-            singleLine: false
-          }),
-          level: options.level || LogLevel.INFO
-        }
-      ])
-    );
-  }
-  debug(message, args = {}) {
-    this.logger.debug(args, message);
-  }
-  info(message, args = {}) {
-    this.logger.info(args, message);
-  }
-  warn(message, args = {}) {
-    this.logger.warn(args, message);
-  }
-  error(message, args = {}) {
-    this.logger.error(args, message);
-  }
-  // Stream creation for process output handling
-  createStream() {
-    return new stream.Transform({
-      transform: (chunk, _encoding, callback) => {
-        const line = chunk.toString().trim();
-        if (line) {
-          this.info(line);
-        }
-        callback(null, chunk);
-      }
-    });
-  }
-  async getLogs(transportId) {
-    if (!transportId || !this.transports[transportId]) {
-      return [];
-    }
-    return this.transports[transportId].getLogs();
-  }
-  async getLogsByRunId({ runId, transportId }) {
-    return this.transports[transportId]?.getLogsByRunId({ runId });
-  }
-};
-function createLogger(options) {
-  return new Logger(options);
-}
-var MultiLogger = class {
-  loggers;
-  constructor(loggers) {
-    this.loggers = loggers;
-  }
-  debug(message, ...args) {
-    this.loggers.forEach((logger) => logger.debug(message, ...args));
-  }
-  info(message, ...args) {
-    this.loggers.forEach((logger) => logger.info(message, ...args));
-  }
-  warn(message, ...args) {
-    this.loggers.forEach((logger) => logger.warn(message, ...args));
-  }
-  error(message, ...args) {
-    this.loggers.forEach((logger) => logger.error(message, ...args));
-  }
-};
-function combineLoggers(loggers) {
-  return new MultiLogger(loggers);
-}
-var noopLogger = {
-  debug: () => {
-  },
-  info: () => {
-  },
-  warn: () => {
-  },
-  error: () => {
-  },
-  cleanup: async () => {
-  }
-};
-
-exports.LogLevel = LogLevel;
-exports.Logger = Logger;
-exports.LoggerTransport = LoggerTransport;
-exports.MultiLogger = MultiLogger;
-exports.RegisteredLogger = RegisteredLogger;
-exports.combineLoggers = combineLoggers;
-exports.createLogger = createLogger;
-exports.noopLogger = noopLogger;

package/dist/chunk-T6DN4C76.cjs

@@ -1,134 +0,0 @@
-'use strict';
-
-var chunk5DUFC7TV_cjs = require('./chunk-5DUFC7TV.cjs');
-
-// src/storage/default-proxy-storage.ts
-var DefaultProxyStorage = class extends chunk5DUFC7TV_cjs.MastraStorage {
-  storage = null;
-  storageConfig;
-  isInitializingPromise = null;
-  constructor({ config }) {
-    super({ name: "DefaultStorage" });
-    this.storageConfig = config;
-  }
-  setupStorage() {
-    if (!this.isInitializingPromise) {
-      this.isInitializingPromise = new Promise((resolve, reject) => {
-        import('./storage/libsql/index.cjs').then(({ DefaultStorage }) => {
-          this.storage = new DefaultStorage({ config: this.storageConfig });
-          resolve();
-        }).catch(reject);
-      });
-    }
-    return this.isInitializingPromise;
-  }
-  async createTable({
-    tableName,
-    schema
-  }) {
-    await this.setupStorage();
-    return this.storage.createTable({ tableName, schema });
-  }
-  async clearTable({ tableName }) {
-    await this.setupStorage();
-    return this.storage.clearTable({ tableName });
-  }
-  async insert({ tableName, record }) {
-    await this.setupStorage();
-    return this.storage.insert({ tableName, record });
-  }
-  async batchInsert({ tableName, records }) {
-    await this.setupStorage();
-    return this.storage.batchInsert({ tableName, records });
-  }
-  async load({ tableName, keys }) {
-    await this.setupStorage();
-    return this.storage.load({ tableName, keys });
-  }
-  async getThreadById({ threadId }) {
-    await this.setupStorage();
-    return this.storage.getThreadById({ threadId });
-  }
-  async getThreadsByResourceId({ resourceId }) {
-    await this.setupStorage();
-    return this.storage.getThreadsByResourceId({ resourceId });
-  }
-  async saveThread({ thread }) {
-    await this.setupStorage();
-    return this.storage.saveThread({ thread });
-  }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    await this.setupStorage();
-    return this.storage.updateThread({ id, title, metadata });
-  }
-  async deleteThread({ threadId }) {
-    await this.setupStorage();
-    return this.storage.deleteThread({ threadId });
-  }
-  async getMessages({ threadId, selectBy }) {
-    await this.setupStorage();
-    return this.storage.getMessages({ threadId, selectBy });
-  }
-  async saveMessages({ messages }) {
-    await this.setupStorage();
-    return this.storage.saveMessages({ messages });
-  }
-  async getEvalsByAgentName(agentName, type) {
-    await this.setupStorage();
-    return this.storage.getEvalsByAgentName(agentName, type);
-  }
-  async getTraces(options) {
-    await this.setupStorage();
-    return this.storage.getTraces(options);
-  }
-  async getWorkflowRuns(args) {
-    await this.setupStorage();
-    return this.storage.getWorkflowRuns(args);
-  }
-  async getWorkflowRunById(args) {
-    await this.setupStorage();
-    return this.storage.getWorkflowRunById(args);
-  }
-};
-
-// src/storage/storageWithInit.ts
-var isAugmentedSymbol = Symbol("isAugmented");
-function augmentWithInit(storage) {
-  let hasInitialized = null;
-  const ensureInit = async () => {
-    if (!hasInitialized) {
-      hasInitialized = storage.init();
-    }
-    await hasInitialized;
-  };
-  if (storage[isAugmentedSymbol]) {
-    return storage;
-  }
-  const proxy = new Proxy(storage, {
-    get(target, prop) {
-      const value = target[prop];
-      if (typeof value === "function" && prop !== "init") {
-        return async (...args) => {
-          await ensureInit();
-          return Reflect.apply(value, target, args);
-        };
-      }
-      return Reflect.get(target, prop);
-    }
-  });
-  Object.defineProperty(proxy, isAugmentedSymbol, {
-    value: true,
-    enumerable: false,
-    // Won't show up in Object.keys() or for...in loops
-    configurable: true
-    // Allows the property to be deleted or modified later if needed
-  });
-  return proxy;
-}
-
-exports.DefaultProxyStorage = DefaultProxyStorage;
-exports.augmentWithInit = augmentWithInit;