@mastra/core 0.0.0-commonjs-20250227130920

package/dist/deployer/index.cjs

@@ -0,0 +1,165 @@
+'use strict';
+
+var promises = require('fs/promises');
+var dotenv = require('dotenv');
+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/bundler/index.ts
+var RegisteredLogger = {
+  LLM: "LLM"};
+var LogLevel = {
+  INFO: "info"};
+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
+      },
+      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);
+}
+
+// src/base.ts
+var MastraBase = class {
+  component = RegisteredLogger.LLM;
+  logger;
+  name;
+  telemetry;
+  constructor({ component, name }) {
+    this.component = component || RegisteredLogger.LLM;
+    this.name = name;
+    this.logger = createLogger({ name: `${this.component} - ${this.name}` });
+  }
+  /**
+   * Set the logger for the agent
+   * @param logger
+   */
+  __setLogger(logger) {
+    this.logger = logger;
+    this.logger.debug(`Logger updated [component=${this.component}] [name=${this.name}]`);
+  }
+  /**
+   * Set the telemetry for the
+   * @param telemetry
+   */
+  __setTelemetry(telemetry) {
+    this.telemetry = telemetry;
+    this.logger.debug(`Telemetry updated [component=${this.component}] [tracer=${this.telemetry.tracer}]`);
+  }
+  /**
+   * Get the telemetry on the vector
+   * @returns telemetry
+   */
+  __getTelemetry() {
+    return this.telemetry;
+  }
+  /* 
+    get experimental_telemetry config
+    */
+  get experimental_telemetry() {
+    return this.telemetry ? {
+      // tracer: this.telemetry.tracer,
+      tracer: this.telemetry.getBaggageTracer(),
+      isEnabled: !!this.telemetry.tracer
+    } : void 0;
+  }
+};
+
+// src/bundler/index.ts
+var MastraBundler = class extends MastraBase {
+  constructor({ name, component = "BUNDLER" }) {
+    super({ component, name });
+  }
+  async loadEnvVars() {
+    const envVars = /* @__PURE__ */ new Map();
+    for (const file of await this.getEnvFiles()) {
+      const content = await promises.readFile(file, "utf-8");
+      const config = dotenv.parse(content);
+      Object.entries(config).forEach(([key, value]) => {
+        envVars.set(key, value);
+      });
+    }
+    return envVars;
+  }
+};
+
+// src/deployer/index.ts
+var MastraDeployer = class extends MastraBundler {
+  constructor({ name }) {
+    super({ component: "DEPLOYER", name });
+  }
+};
+
+exports.MastraDeployer = MastraDeployer;

package/dist/deployer/index.d.cts

@@ -0,0 +1,19 @@
+import { MastraBundler, IBundler } from '../bundler/index.cjs';
+import '../base-hs9NDAZ2.cjs';
+import '@opentelemetry/api';
+import '../index-mKY1XrpK.cjs';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+
+interface IDeployer extends IBundler {
+    deploy(outputDirectory: string): Promise<void>;
+}
+declare abstract class MastraDeployer extends MastraBundler implements IDeployer {
+    constructor({ name }: {
+        name: string;
+    });
+    abstract deploy(outputDirectory: string): Promise<void>;
+}
+
+export { type IDeployer, MastraDeployer };

package/dist/deployer/index.d.ts

@@ -0,0 +1,19 @@
+import { MastraBundler, IBundler } from '../bundler/index.js';
+import '../base-D90KQ4XI.js';
+import '@opentelemetry/api';
+import '../index-mKY1XrpK.js';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+
+interface IDeployer extends IBundler {
+    deploy(outputDirectory: string): Promise<void>;
+}
+declare abstract class MastraDeployer extends MastraBundler implements IDeployer {
+    constructor({ name }: {
+        name: string;
+    });
+    abstract deploy(outputDirectory: string): Promise<void>;
+}
+
+export { type IDeployer, MastraDeployer };

package/dist/deployer/index.js

@@ -0,0 +1 @@
+export { MastraDeployer } from '../chunk-4YRYBCOZ.js';

package/dist/eval/index.cjs

@@ -0,0 +1,110 @@
+'use strict';
+
+// src/eval/metric.ts
+var Metric = class {
+};
+
+// src/hooks/mitt.ts
+function mitt(all) {
+  all = all || /* @__PURE__ */ new Map();
+  return {
+    /**
+     * A Map of event names to registered handler functions.
+     */
+    all,
+    /**
+     * Register an event handler for the given type.
+     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events
+     * @param {Function} handler Function to call in response to given event
+     * @memberOf mitt
+     */
+    on(type, handler) {
+      const handlers = all.get(type);
+      if (handlers) {
+        handlers.push(handler);
+      } else {
+        all.set(type, [handler]);
+      }
+    },
+    /**
+     * Remove an event handler for the given type.
+     * If `handler` is omitted, all handlers of the given type are removed.
+     * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)
+     * @param {Function} [handler] Handler function to remove
+     * @memberOf mitt
+     */
+    off(type, handler) {
+      const handlers = all.get(type);
+      if (handlers) {
+        if (handler) {
+          handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+        } else {
+          all.set(type, []);
+        }
+      }
+    },
+    /**
+     * Invoke all handlers for the given type.
+     * If present, `'*'` handlers are invoked after type-matched handlers.
+     *
+     * Note: Manually firing '*' handlers is not supported.
+     *
+     * @param {string|symbol} type The event type to invoke
+     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
+     * @memberOf mitt
+     */
+    emit(type, evt) {
+      let handlers = all.get(type);
+      if (handlers) {
+        handlers.slice().map((handler) => {
+          handler(evt);
+        });
+      }
+      handlers = all.get("*");
+      if (handlers) {
+        handlers.slice().map((handler) => {
+          handler(type, evt);
+        });
+      }
+    }
+  };
+}
+
+// src/hooks/index.ts
+var hooks = mitt();
+function executeHook(hook, data) {
+  setImmediate(() => {
+    hooks.emit(hook, data);
+  });
+}
+
+// src/eval/evaluation.ts
+async function evaluate({
+  agentName,
+  input,
+  metric,
+  output,
+  runId,
+  globalRunId,
+  testInfo,
+  instructions
+}) {
+  const runIdToUse = runId || crypto.randomUUID();
+  const metricResult = await metric.measure(input.toString(), output);
+  const traceObject = {
+    input: input.toString(),
+    output,
+    result: metricResult,
+    agentName,
+    metricName: metric.constructor.name,
+    instructions,
+    globalRunId,
+    runId: runIdToUse,
+    testInfo
+  };
+  executeHook("onEvaluation" /* ON_EVALUATION */, traceObject);
+  return metricResult;
+}
+
+exports.Metric = Metric;
+exports.evaluate = evaluate;

package/dist/eval/index.d.cts

@@ -0,0 +1,28 @@
+import { a as Metric, T as TestInfo, M as MetricResult } from '../types-m9RryK9a.cjs';
+import { A as Agent } from '../base-nhesrHv3.cjs';
+import 'ai';
+import '../base-hs9NDAZ2.cjs';
+import '@opentelemetry/api';
+import '../index-mKY1XrpK.cjs';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+import 'sift';
+import 'zod';
+import 'json-schema';
+import '../vector/index.cjs';
+import '../voice/index.cjs';
+import '../tts/index.cjs';
+
+declare function evaluate<T extends Agent>({ agentName, input, metric, output, runId, globalRunId, testInfo, instructions, }: {
+    agentName: string;
+    input: Parameters<T['generate']>[0];
+    metric: Metric;
+    output: string;
+    globalRunId: string;
+    runId?: string;
+    testInfo?: TestInfo;
+    instructions: string;
+}): Promise<MetricResult>;
+
+export { Metric, MetricResult, TestInfo, evaluate };

package/dist/eval/index.d.ts

@@ -0,0 +1,28 @@
+import { a as Metric, T as TestInfo, M as MetricResult } from '../types-m9RryK9a.js';
+import { A as Agent } from '../base-nKCMCNrM.js';
+import 'ai';
+import '../base-D90KQ4XI.js';
+import '@opentelemetry/api';
+import '../index-mKY1XrpK.js';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+import 'sift';
+import 'zod';
+import 'json-schema';
+import '../vector/index.js';
+import '../voice/index.js';
+import '../tts/index.js';
+
+declare function evaluate<T extends Agent>({ agentName, input, metric, output, runId, globalRunId, testInfo, instructions, }: {
+    agentName: string;
+    input: Parameters<T['generate']>[0];
+    metric: Metric;
+    output: string;
+    globalRunId: string;
+    runId?: string;
+    testInfo?: TestInfo;
+    instructions: string;
+}): Promise<MetricResult>;
+
+export { Metric, MetricResult, TestInfo, evaluate };

package/dist/eval/index.js

@@ -0,0 +1 @@
+export { Metric, evaluate } from '../chunk-NUDAZEOG.js';

package/dist/filter/index.cjs

@@ -0,0 +1,192 @@
+'use strict';
+
+// src/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 };
+  }
+};
+
+exports.BaseFilterTranslator = BaseFilterTranslator;

package/dist/filter/index.d.cts

@@ -0,0 +1,90 @@
+type BasicOperator = '$eq' | '$ne';
+type NumericOperator = '$gt' | '$gte' | '$lt' | '$lte';
+type LogicalOperator = '$and' | '$not' | '$nor' | '$or';
+type ArrayOperator = '$all' | '$in' | '$nin' | '$elemMatch';
+type ElementOperator = '$exists';
+type RegexOperator = '$regex' | '$options';
+type QueryOperator = BasicOperator | NumericOperator | LogicalOperator | ArrayOperator | ElementOperator | RegexOperator;
+type OperatorCondition = {
+    [K in QueryOperator]?: any;
+};
+type FieldCondition = OperatorCondition | any;
+type Filter = {
+    [field: string]: FieldCondition | Filter;
+};
+type OperatorSupport = {
+    logical?: LogicalOperator[];
+    array?: ArrayOperator[];
+    basic?: BasicOperator[];
+    numeric?: NumericOperator[];
+    element?: ElementOperator[];
+    regex?: RegexOperator[];
+    custom?: string[];
+};
+declare abstract class BaseFilterTranslator {
+    abstract translate(filter: Filter): unknown;
+    /**
+     * Operator type checks
+     */
+    protected isOperator(key: string): key is QueryOperator;
+    protected static readonly BASIC_OPERATORS: BasicOperator[];
+    protected static readonly NUMERIC_OPERATORS: NumericOperator[];
+    protected static readonly ARRAY_OPERATORS: ArrayOperator[];
+    protected static readonly LOGICAL_OPERATORS: LogicalOperator[];
+    protected static readonly ELEMENT_OPERATORS: ElementOperator[];
+    protected static readonly REGEX_OPERATORS: RegexOperator[];
+    static readonly DEFAULT_OPERATORS: {
+        logical: LogicalOperator[];
+        basic: BasicOperator[];
+        numeric: NumericOperator[];
+        array: ArrayOperator[];
+        element: "$exists"[];
+        regex: RegexOperator[];
+    };
+    protected isLogicalOperator(key: string): key is LogicalOperator;
+    protected isBasicOperator(key: string): key is BasicOperator;
+    protected isNumericOperator(key: string): key is NumericOperator;
+    protected isArrayOperator(key: string): key is ArrayOperator;
+    protected isElementOperator(key: string): key is ElementOperator;
+    protected isRegexOperator(key: string): key is RegexOperator;
+    protected isFieldOperator(key: string): key is QueryOperator;
+    protected isCustomOperator(key: string): boolean;
+    protected getSupportedOperators(): OperatorSupport;
+    protected isValidOperator(key: string): boolean;
+    /**
+     * Value normalization for comparison operators
+     */
+    protected normalizeComparisonValue(value: any): any;
+    /**
+     * Helper method to simulate $all operator using $and + $eq when needed.
+     * Some vector stores don't support $all natively.
+     */
+    protected simulateAllOperator(field: string, values: any[]): Filter;
+    /**
+     * Utility functions for type checking
+     */
+    protected isPrimitive(value: any): boolean;
+    protected isRegex(value: any): boolean;
+    protected isEmpty(obj: any): boolean;
+    protected static readonly ErrorMessages: {
+        readonly UNSUPPORTED_OPERATOR: (op: string) => string;
+        readonly INVALID_LOGICAL_OPERATOR_LOCATION: (op: string, path: string) => string;
+        readonly NOT_REQUIRES_OBJECT: "$not operator requires an object";
+        readonly NOT_CANNOT_BE_EMPTY: "$not operator cannot be empty";
+        readonly INVALID_LOGICAL_OPERATOR_CONTENT: (path: string) => string;
+        readonly INVALID_TOP_LEVEL_OPERATOR: (op: string) => string;
+        readonly ELEM_MATCH_REQUIRES_OBJECT: "$elemMatch requires an object with conditions";
+    };
+    /**
+     * Helper to handle array value normalization consistently
+     */
+    protected normalizeArrayValues(values: any[]): any[];
+    protected validateFilter(filter: Filter): void;
+    /**
+     * Validates if a filter structure is supported by the specific vector DB
+     * and returns detailed validation information.
+     */
+    private validateFilterSupport;
+}
+
+export { type ArrayOperator, BaseFilterTranslator, type BasicOperator, type ElementOperator, type FieldCondition, type Filter, type LogicalOperator, type NumericOperator, type OperatorCondition, type OperatorSupport, type QueryOperator, type RegexOperator };