@mastra/core 0.5.0-alpha.8 → 0.5.0

package/dist/chunk-GXQRMKSN.cjs

@@ -0,0 +1,367 @@
+'use strict';
+
+var chunkVA4P7QJT_cjs = require('./chunk-VA4P7QJT.cjs');
+var chunkXB2TJ7LX_cjs = require('./chunk-XB2TJ7LX.cjs');
+var chunkWB2HREXE_cjs = require('./chunk-WB2HREXE.cjs');
+var chunkRWTSGWWL_cjs = require('./chunk-RWTSGWWL.cjs');
+
+// src/mastra/index.ts
+var _Mastra_decorators, _init;
+_Mastra_decorators = [chunkXB2TJ7LX_cjs.InstrumentClass({
+  prefix: "mastra",
+  excludeMethods: ["getLogger", "getTelemetry"]
+})];
+exports.Mastra = class Mastra {
+  #vectors;
+  #agents;
+  #logger;
+  #workflows;
+  #tts;
+  #deployer;
+  #serverMiddleware = [];
+  #telemetry;
+  /**
+   * @deprecated use getStorage() instead
+   */
+  storage;
+  /**
+   * @deprecated use getMemory() instead
+   */
+  memory;
+  /**
+   * @deprecated use getTelemetry() instead
+   */
+  get telemetry() {
+    return this.#telemetry;
+  }
+  constructor(config) {
+    if (config?.serverMiddleware) {
+      this.#serverMiddleware = config.serverMiddleware.map(m => ({
+        handler: m.handler,
+        path: m.path || "/api/*"
+      }));
+    }
+    let logger;
+    if (config?.logger === false) {
+      logger = chunkWB2HREXE_cjs.noopLogger;
+    } else {
+      if (config?.logger) {
+        logger = config.logger;
+      } else {
+        const levleOnEnv = process.env.NODE_ENV === "production" ? chunkWB2HREXE_cjs.LogLevel.WARN : chunkWB2HREXE_cjs.LogLevel.INFO;
+        logger = chunkWB2HREXE_cjs.createLogger({
+          name: "Mastra",
+          level: levleOnEnv
+        });
+      }
+    }
+    this.#logger = logger;
+    let storage = config?.storage;
+    if (!storage) {
+      storage = new chunkVA4P7QJT_cjs.LibSQLStore({
+        config: {
+          url: process.env.MASTRA_DEFAULT_STORAGE_URL || `:memory:`
+        }
+      });
+    }
+    if (storage instanceof chunkVA4P7QJT_cjs.LibSQLStore && config?.telemetry?.export?.type !== "custom") {
+      const newTelemetry = {
+        ...(config?.telemetry || {}),
+        export: {
+          type: "custom",
+          exporter: new chunkXB2TJ7LX_cjs.OTLPTraceExporter({
+            logger: this.getLogger(),
+            storage
+          })
+        }
+      };
+      this.#telemetry = chunkXB2TJ7LX_cjs.Telemetry.init(newTelemetry);
+    } else if (config?.telemetry) {
+      this.#telemetry = chunkXB2TJ7LX_cjs.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
+        });
+        agent.__registerMastra(this);
+        agents[key] = agent;
+      });
+    }
+    this.#agents = agents;
+    this.#workflows = {};
+    if (config?.workflows) {
+      Object.entries(config.workflows).forEach(([key, workflow]) => {
+        workflow.__registerMastra(this);
+        workflow.__registerPrimitives({
+          logger: this.getLogger(),
+          telemetry: this.#telemetry,
+          storage: this.storage,
+          memory: this.memory,
+          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.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 = chunkXB2TJ7LX_cjs.Telemetry.init(telemetry);
+    if (this.#agents) {
+      Object.keys(this.#agents).forEach(key => {
+        if (this.#telemetry) {
+          this.#agents?.[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;
+    }
+  }
+  getTTS() {
+    return this.#tts;
+  }
+  getLogger() {
+    return this.#logger;
+  }
+  getTelemetry() {
+    return this.#telemetry;
+  }
+  getMemory() {
+    return this.memory;
+  }
+  getStorage() {
+    return this.storage;
+  }
+  getServerMiddleware() {
+    return this.#serverMiddleware;
+  }
+  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);
+  }
+};
+exports.Mastra = /*@__PURE__*/(_ => {
+  _init = chunkRWTSGWWL_cjs.__decoratorStart(null);
+  exports.Mastra = chunkRWTSGWWL_cjs.__decorateElement(_init, 0, "Mastra", _Mastra_decorators, exports.Mastra);
+  chunkRWTSGWWL_cjs.__runInitializers(_init, 1, exports.Mastra);
+  return exports.Mastra;
+})();

package/dist/chunk-HJPMYDWO.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var chunkXB2TJ7LX_cjs = require('./chunk-XB2TJ7LX.cjs');
+var chunkIIWRJFLQ_cjs = require('./chunk-IIWRJFLQ.cjs');
+var chunkRWTSGWWL_cjs = require('./chunk-RWTSGWWL.cjs');
+
+// src/tts/index.ts
+var _MastraTTS_decorators, _init, _a;
+_MastraTTS_decorators = [chunkXB2TJ7LX_cjs.InstrumentClass({
+  prefix: "tts",
+  excludeMethods: ["__setTools", "__setLogger", "__setTelemetry", "#log"]
+})];
+exports.MastraTTS = class MastraTTS extends (_a = chunkIIWRJFLQ_cjs.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;
+  }
+};
+exports.MastraTTS = /*@__PURE__*/(_ => {
+  _init = chunkRWTSGWWL_cjs.__decoratorStart(_a);
+  exports.MastraTTS = chunkRWTSGWWL_cjs.__decorateElement(_init, 0, "MastraTTS", _MastraTTS_decorators, exports.MastraTTS);
+  chunkRWTSGWWL_cjs.__runInitializers(_init, 1, exports.MastraTTS);
+  return exports.MastraTTS;
+})();

package/dist/chunk-IIWRJFLQ.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+var chunkWB2HREXE_cjs = require('./chunk-WB2HREXE.cjs');
+
+// src/base.ts
+var MastraBase = class {
+  component = chunkWB2HREXE_cjs.RegisteredLogger.LLM;
+  logger;
+  name;
+  telemetry;
+  constructor({ component, name }) {
+    this.component = component || chunkWB2HREXE_cjs.RegisteredLogger.LLM;
+    this.name = name;
+    this.logger = chunkWB2HREXE_cjs.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;
+  }
+};
+
+exports.MastraBase = MastraBase;