@mastra/core 0.0.0-commonjs-20250227130920

package/dist/chunk-NGD2HQYW.js

@@ -0,0 +1,346 @@
+import { LibSQLStore } from './chunk-KNVTCZW7.js';
+import { InstrumentClass, OTLPTraceExporter, Telemetry } from './chunk-W5HVJX45.js';
+import { createLogger, LogLevel, noopLogger } from './chunk-PHMSPCTC.js';
+import { __decoratorStart, __decorateElement, __runInitializers } from './chunk-C6A6W6XS.js';
+
+// src/mastra/index.ts
+var _Mastra_decorators, _init;
+_Mastra_decorators = [InstrumentClass({
+  prefix: "mastra",
+  excludeMethods: ["getLogger", "getTelemetry"]
+})];
+var Mastra = class {
+  vectors;
+  agents;
+  logger;
+  workflows;
+  telemetry;
+  tts;
+  deployer;
+  storage;
+  memory;
+  constructor(config) {
+    let logger;
+    if (config?.logger === false) {
+      logger = noopLogger;
+    } else {
+      if (config?.logger) {
+        logger = config.logger;
+      } else {
+        const levleOnEnv = process.env.NODE_ENV === "production" ? LogLevel.WARN : LogLevel.INFO;
+        logger = createLogger({
+          name: "Mastra",
+          level: levleOnEnv
+        });
+      }
+    }
+    this.logger = logger;
+    let storage = config?.storage;
+    if (!storage) {
+      storage = new LibSQLStore({
+        config: {
+          url: process.env.MASTRA_DEFAULT_STORAGE_URL || `:memory:`
+        }
+      });
+    }
+    if (storage instanceof LibSQLStore && config?.telemetry?.export?.type !== "custom") {
+      const newTelemetry = {
+        ...(config?.telemetry || {}),
+        export: {
+          type: "custom",
+          exporter: new OTLPTraceExporter({
+            logger: this.getLogger(),
+            storage
+          })
+        }
+      };
+      this.telemetry = Telemetry.init(newTelemetry);
+    } else if (config?.telemetry) {
+      this.telemetry = Telemetry.init(config?.telemetry);
+    }
+    if (config?.deployer) {
+      this.deployer = config.deployer;
+      if (this.telemetry) {
+        this.deployer = this.telemetry.traceClass(config.deployer, {
+          excludeMethods: ["__setTelemetry", "__getTelemetry"]
+        });
+        this.deployer.__setTelemetry(this.telemetry);
+      }
+    }
+    if (this.telemetry) {
+      this.storage = this.telemetry.traceClass(storage, {
+        excludeMethods: ["__setTelemetry", "__getTelemetry"]
+      });
+      this.storage.__setTelemetry(this.telemetry);
+    } else {
+      this.storage = storage;
+    }
+    if (config?.vectors) {
+      let vectors = {};
+      Object.entries(config.vectors).forEach(([key, vector]) => {
+        if (this.telemetry) {
+          vectors[key] = this.telemetry.traceClass(vector, {
+            excludeMethods: ["__setTelemetry", "__getTelemetry"]
+          });
+          vectors[key].__setTelemetry(this.telemetry);
+        } else {
+          vectors[key] = vector;
+        }
+      });
+      this.vectors = vectors;
+    }
+    if (config?.vectors) {
+      this.vectors = config.vectors;
+    }
+    if (config?.memory) {
+      this.memory = config.memory;
+      if (this.telemetry) {
+        this.memory = this.telemetry.traceClass(config.memory, {
+          excludeMethods: ["__setTelemetry", "__getTelemetry"]
+        });
+        this.memory.__setTelemetry(this.telemetry);
+      }
+    }
+    if (config && `memory` in config) {
+      this.logger.warn(`
+  Memory should be added to Agents, not to Mastra.
+
+Instead of:
+  new Mastra({ memory: new Memory() })
+
+do:
+  new Agent({ memory: new Memory() })
+
+This is a warning for now, but will throw an error in the future
+`);
+    }
+    if (config?.tts) {
+      this.tts = config.tts;
+      Object.entries(this.tts).forEach(([key, ttsCl]) => {
+        if (this.tts?.[key]) {
+          if (this.telemetry) {
+            this.tts[key] = this.telemetry.traceClass(ttsCl, {
+              excludeMethods: ["__setTelemetry", "__getTelemetry"]
+            });
+            this.tts[key].__setTelemetry(this.telemetry);
+          }
+        }
+      });
+    }
+    const agents = {};
+    if (config?.agents) {
+      Object.entries(config.agents).forEach(([key, agent]) => {
+        if (agents[key]) {
+          throw new Error(`Agent with name ID:${key} already exists`);
+        }
+        agent.__registerPrimitives({
+          logger: this.getLogger(),
+          telemetry: this.telemetry,
+          storage: this.storage,
+          memory: this.memory,
+          agents,
+          tts: this.tts,
+          vectors: this.vectors
+        });
+        agents[key] = agent;
+      });
+    }
+    this.agents = agents;
+    this.workflows = {};
+    if (config?.workflows) {
+      Object.entries(config.workflows).forEach(([key, workflow]) => {
+        workflow.__registerPrimitives({
+          logger: this.getLogger(),
+          telemetry: this.telemetry,
+          storage: this.storage,
+          memory: this.memory,
+          agents: this.agents,
+          tts: this.tts,
+          vectors: this.vectors
+        });
+        this.workflows[key] = workflow;
+      });
+    }
+    this.setLogger({
+      logger
+    });
+  }
+  getAgent(name) {
+    const agent = this.agents?.[name];
+    if (!agent) {
+      throw new Error(`Agent with name ${String(name)} not found`);
+    }
+    return this.agents[name];
+  }
+  getAgents() {
+    return this.agents;
+  }
+  getVector(name) {
+    const vector = this.vectors?.[name];
+    if (!vector) {
+      throw new Error(`Vector with name ${String(name)} not found`);
+    }
+    return vector;
+  }
+  getVectors() {
+    return this.vectors;
+  }
+  getDeployer() {
+    return this.deployer;
+  }
+  getWorkflow(id, {
+    serialized
+  } = {}) {
+    const workflow = this.workflows?.[id];
+    if (!workflow) {
+      throw new Error(`Workflow with ID ${String(id)} not found`);
+    }
+    if (serialized) {
+      return {
+        name: workflow.name
+      };
+    }
+    return workflow;
+  }
+  getWorkflows(props = {}) {
+    if (props.serialized) {
+      return Object.entries(this.workflows).reduce((acc, [k, v]) => {
+        return {
+          ...acc,
+          [k]: {
+            name: v.name
+          }
+        };
+      }, {});
+    }
+    return this.workflows;
+  }
+  setStorage(storage) {
+    this.storage = storage;
+  }
+  setLogger({
+    logger
+  }) {
+    this.logger = logger;
+    if (this.agents) {
+      Object.keys(this.agents).forEach(key => {
+        this.agents?.[key]?.__setLogger(this.logger);
+      });
+    }
+    if (this.workflows) {
+      Object.keys(this.workflows).forEach(key => {
+        this.workflows?.[key]?.__setLogger(this.logger);
+      });
+    }
+    if (this.memory) {
+      this.memory.__setLogger(this.logger);
+    }
+    if (this.deployer) {
+      this.deployer.__setLogger(this.logger);
+    }
+    if (this.tts) {
+      Object.keys(this.tts).forEach(key => {
+        this.tts?.[key]?.__setLogger(this.logger);
+      });
+    }
+    if (this.storage) {
+      this.storage.__setLogger(this.logger);
+    }
+    if (this.vectors) {
+      Object.keys(this.vectors).forEach(key => {
+        this.vectors?.[key]?.__setLogger(this.logger);
+      });
+    }
+  }
+  setTelemetry(telemetry) {
+    this.telemetry = Telemetry.init(telemetry);
+    if (this.agents) {
+      Object.keys(this.agents).forEach(key => {
+        if (this.telemetry) {
+          this.agents?.[key]?.__setTelemetry(this.telemetry);
+        }
+      });
+    }
+    if (this.workflows) {
+      Object.keys(this.workflows).forEach(key => {
+        if (this.telemetry) {
+          this.workflows?.[key]?.__setTelemetry(this.telemetry);
+        }
+      });
+    }
+    if (this.memory) {
+      this.memory = this.telemetry.traceClass(this.memory, {
+        excludeMethods: ["__setTelemetry", "__getTelemetry"]
+      });
+      this.memory.__setTelemetry(this.telemetry);
+    }
+    if (this.deployer) {
+      this.deployer = this.telemetry.traceClass(this.deployer, {
+        excludeMethods: ["__setTelemetry", "__getTelemetry"]
+      });
+      this.deployer.__setTelemetry(this.telemetry);
+    }
+    if (this.tts) {
+      let tts = {};
+      Object.entries(this.tts).forEach(([key, ttsCl]) => {
+        if (this.telemetry) {
+          tts[key] = this.telemetry.traceClass(ttsCl, {
+            excludeMethods: ["__setTelemetry", "__getTelemetry"]
+          });
+          tts[key].__setTelemetry(this.telemetry);
+        }
+      });
+      this.tts = tts;
+    }
+    if (this.storage) {
+      this.storage = this.telemetry.traceClass(this.storage, {
+        excludeMethods: ["__setTelemetry", "__getTelemetry"]
+      });
+      this.storage.__setTelemetry(this.telemetry);
+    }
+    if (this.vectors) {
+      let vectors = {};
+      Object.entries(this.vectors).forEach(([key, vector]) => {
+        if (this.telemetry) {
+          vectors[key] = this.telemetry.traceClass(vector, {
+            excludeMethods: ["__setTelemetry", "__getTelemetry"]
+          });
+          vectors[key].__setTelemetry(this.telemetry);
+        }
+      });
+      this.vectors = vectors;
+    }
+  }
+  getLogger() {
+    return this.logger;
+  }
+  getTelemetry() {
+    return this.telemetry;
+  }
+  async getLogsByRunId({
+    runId,
+    transportId
+  }) {
+    if (!transportId) {
+      throw new Error("Transport ID is required");
+    }
+    return await this.logger.getLogsByRunId({
+      runId,
+      transportId
+    });
+  }
+  async getLogs(transportId) {
+    if (!transportId) {
+      throw new Error("Transport ID is required");
+    }
+    return await this.logger.getLogs(transportId);
+  }
+};
+Mastra = /*@__PURE__*/(_ => {
+  _init = __decoratorStart(null);
+  Mastra = __decorateElement(_init, 0, "Mastra", _Mastra_decorators, Mastra);
+  __runInitializers(_init, 1, Mastra);
+  return Mastra;
+})();
+
+export { Mastra };

package/dist/chunk-NUDAZEOG.js

@@ -0,0 +1,35 @@
+import { executeHook } from './chunk-BB4KXGBU.js';
+
+// src/eval/metric.ts
+var Metric = class {
+};
+
+// 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;
+}
+
+export { Metric, evaluate };

package/dist/chunk-OZ4XVJ6F.js

@@ -0,0 +1,49 @@
+import { RegisteredLogger, createLogger } from './chunk-PHMSPCTC.js';
+
+// 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;
+  }
+};
+
+export { MastraBase };

package/dist/chunk-PHMSPCTC.js

@@ -0,0 +1,145 @@
+import { Transform } from 'stream';
+import pino from 'pino';
+import pretty from 'pino-pretty';
+
+// src/logger/index.ts
+var RegisteredLogger = {
+  AGENT: "AGENT",
+  WORKFLOW: "WORKFLOW",
+  LLM: "LLM",
+  TTS: "TTS",
+  VOICE: "VOICE",
+  VECTOR: "VECTOR",
+  BUNDLER: "BUNDLER",
+  DEPLOYER: "DEPLOYER",
+  MEMORY: "MEMORY",
+  STORAGE: "STORAGE",
+  EMBEDDINGS: "EMBEDDINGS"
+};
+var LogLevel = {
+  DEBUG: "debug",
+  INFO: "info",
+  WARN: "warn",
+  ERROR: "error",
+  NONE: "silent"
+};
+var LoggerTransport = class extends 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(
+      {
+        name: options.name || "app",
+        level: options.level || LogLevel.INFO
+      },
+      options.overrideDefaultTransports ? options?.transports?.default : transportsAry.length === 0 ? pretty({
+        colorize: true,
+        levelFirst: true,
+        ignore: "pid,hostname",
+        colorizeObjects: true,
+        translateTime: "SYS:standard",
+        singleLine: false
+      }) : pino.multistream([
+        ...transportsAry.map(([_, transport]) => ({
+          stream: transport,
+          level: options.level || LogLevel.INFO
+        })),
+        {
+          stream: pretty({
+            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 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 () => {
+  }
+};
+
+export { LogLevel, Logger, LoggerTransport, MultiLogger, RegisteredLogger, combineLoggers, createLogger, noopLogger };

package/dist/chunk-PNZK456O.js

@@ -0,0 +1,88 @@
+import { createTool } from './chunk-ZINPRHAN.js';
+import { z } from 'zod';
+
+// src/integration/integration.ts
+var Integration = class {
+  name = "Integration";
+  workflows;
+  constructor() {
+    this.workflows = {};
+  }
+  /**
+   * Workflows
+   */
+  registerWorkflow(name, fn) {
+    if (this.workflows[name]) {
+      throw new Error(`Sync function "${name}" already registered`);
+    }
+    this.workflows[name] = fn;
+  }
+  getWorkflows({ serialized }) {
+    if (serialized) {
+      return Object.entries(this.workflows).reduce((acc, [k, v]) => {
+        return {
+          ...acc,
+          [k]: {
+            name: v.name
+          }
+        };
+      }, {});
+    }
+    return this.workflows;
+  }
+  /**
+   * TOOLS
+   */
+  getStaticTools(_params) {
+    throw new Error("Method not implemented.");
+  }
+  async getTools(_params) {
+    throw new Error("Method not implemented.");
+  }
+  async getApiClient() {
+    throw new Error("Method not implemented");
+  }
+};
+var OpenAPIToolset = class {
+  authType = "API_KEY";
+  constructor() {
+  }
+  get toolSchemas() {
+    return {};
+  }
+  get toolDocumentations() {
+    return {};
+  }
+  get baseClient() {
+    return {};
+  }
+  async getApiClient() {
+    throw new Error("API not implemented");
+  }
+  _generateIntegrationTools() {
+    const { client, ...clientMethods } = this.baseClient;
+    const schemas = this.toolSchemas;
+    const documentations = this.toolDocumentations;
+    const tools = Object.keys(clientMethods).reduce((acc, key) => {
+      const comment = documentations[key]?.comment;
+      const fallbackComment = `Execute ${key}`;
+      const tool = createTool({
+        id: key,
+        inputSchema: schemas[key] || z.object({}),
+        description: comment || fallbackComment,
+        // documentation: doc || fallbackComment,
+        execute: async ({ context }) => {
+          const client2 = await this.getApiClient();
+          const value = client2[key];
+          return value({
+            ...context
+          });
+        }
+      });
+      return { ...acc, [key]: tool };
+    }, {});
+    return tools;
+  }
+};
+
+export { Integration, OpenAPIToolset };

package/dist/chunk-QAAJAHDB.js

@@ -0,0 +1,37 @@
+import { InstrumentClass } from './chunk-W5HVJX45.js';
+import { MastraBase } from './chunk-OZ4XVJ6F.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;
+  }
+};
+MastraTTS = /*@__PURE__*/(_ => {
+  _init = __decoratorStart(_a);
+  MastraTTS = __decorateElement(_init, 0, "MastraTTS", _MastraTTS_decorators, MastraTTS);
+  __runInitializers(_init, 1, MastraTTS);
+  return MastraTTS;
+})();
+
+export { MastraTTS };

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 };