@mastra/core 0.10.13 → 0.10.15-alpha.0

package/dist/chunk-7H2GET5Z.cjs

@@ -0,0 +1,668 @@
+'use strict';
+
+var chunkLXFZUKP3_cjs = require('./chunk-LXFZUKP3.cjs');
+var chunkQQ5K5TZE_cjs = require('./chunk-QQ5K5TZE.cjs');
+var chunk6Y4UL5Z6_cjs = require('./chunk-6Y4UL5Z6.cjs');
+var chunkB6TOBUS6_cjs = require('./chunk-B6TOBUS6.cjs');
+var chunkZIZ3CVHN_cjs = require('./chunk-ZIZ3CVHN.cjs');
+var chunkU64IJDC5_cjs = require('./chunk-U64IJDC5.cjs');
+
+// src/mastra/index.ts
+var _Mastra_decorators, _init;
+_Mastra_decorators = [chunkQQ5K5TZE_cjs.InstrumentClass({
+  prefix: "mastra",
+  excludeMethods: ["getLogger", "getTelemetry"]
+})];
+exports.Mastra = class Mastra {
+  #vectors;
+  #agents;
+  #logger;
+  #legacy_workflows;
+  #workflows;
+  #tts;
+  #deployer;
+  #serverMiddleware = [];
+  #telemetry;
+  #storage;
+  #memory;
+  #networks;
+  #vnext_networks;
+  #server;
+  #mcpServers;
+  #bundler;
+  /**
+   * @deprecated use getTelemetry() instead
+   */
+  get telemetry() {
+    return this.#telemetry;
+  }
+  /**
+   * @deprecated use getStorage() instead
+   */
+  get storage() {
+    return this.#storage;
+  }
+  /**
+   * @deprecated use getMemory() instead
+   */
+  get memory() {
+    return this.#memory;
+  }
+  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 = chunk6Y4UL5Z6_cjs.noopLogger;
+    } else {
+      if (config?.logger) {
+        logger = config.logger;
+      } else {
+        const levelOnEnv = process.env.NODE_ENV === "production" && process.env.MASTRA_DEV !== "true" ? chunkZIZ3CVHN_cjs.LogLevel.WARN : chunkZIZ3CVHN_cjs.LogLevel.INFO;
+        logger = new chunkZIZ3CVHN_cjs.ConsoleLogger({
+          name: "Mastra",
+          level: levelOnEnv
+        });
+      }
+    }
+    this.#logger = logger;
+    let storage = config?.storage;
+    if (storage) {
+      storage = chunkLXFZUKP3_cjs.augmentWithInit(storage);
+    }
+    this.#telemetry = chunkQQ5K5TZE_cjs.Telemetry.init(config?.telemetry);
+    if (this.#telemetry && storage) {
+      this.#storage = this.#telemetry.traceClass(storage, {
+        excludeMethods: ["__setTelemetry", "__getTelemetry", "batchTraceInsert", "getTraces", "getEvalsByAgentName"]
+      });
+      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?.networks) {
+      this.#networks = config.networks;
+    }
+    if (config?.vnext_networks) {
+      this.#vnext_networks = config.vnext_networks;
+    }
+    if (config?.mcpServers) {
+      this.#mcpServers = config.mcpServers;
+      Object.entries(this.#mcpServers).forEach(([key, server]) => {
+        server.setId(key);
+        if (this.#telemetry) {
+          server.__setTelemetry(this.#telemetry);
+        }
+        server.__registerMastra(this);
+        server.__setLogger(this.getLogger());
+      });
+    }
+    if (config && `memory` in config) {
+      const error = new chunkB6TOBUS6_cjs.MastraError({
+        id: "MASTRA_CONSTRUCTOR_INVALID_MEMORY_CONFIG",
+        domain: "MASTRA" /* MASTRA */,
+        category: "USER" /* USER */,
+        text: `
+  Memory should be added to Agents, not to Mastra.
+
+Instead of:
+  new Mastra({ memory: new Memory() })
+
+do:
+  new Agent({ memory: new Memory() })
+`
+      });
+      this.#logger?.trackException(error);
+      throw error;
+    }
+    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]) {
+          const error = new chunkB6TOBUS6_cjs.MastraError({
+            id: "MASTRA_AGENT_REGISTRATION_DUPLICATE_ID",
+            domain: "MASTRA" /* MASTRA */,
+            category: "USER" /* USER */,
+            text: `Agent with name ID:${key} already exists`,
+            details: {
+              agentId: key
+            }
+          });
+          this.#logger?.trackException(error);
+          throw error;
+        }
+        agent.__registerMastra(this);
+        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.#networks = {};
+    this.#vnext_networks = {};
+    if (config?.networks) {
+      Object.entries(config.networks).forEach(([key, network]) => {
+        network.__registerMastra(this);
+        this.#networks[key] = network;
+      });
+    }
+    if (config?.vnext_networks) {
+      Object.entries(config.vnext_networks).forEach(([key, network]) => {
+        network.__registerMastra(this);
+        this.#vnext_networks[key] = network;
+      });
+    }
+    this.#legacy_workflows = {};
+    if (config?.legacy_workflows) {
+      Object.entries(config.legacy_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.#legacy_workflows[key] = workflow;
+        const workflowSteps = Object.values(workflow.steps).filter(step => !!step.workflowId && !!step.workflow);
+        if (workflowSteps.length > 0) {
+          workflowSteps.forEach(step => {
+            this.#legacy_workflows[step.workflowId] = step.workflow;
+          });
+        }
+      });
+    }
+    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;
+      });
+    }
+    if (config?.server) {
+      this.#server = config.server;
+    }
+    this.setLogger({
+      logger
+    });
+  }
+  getAgent(name) {
+    const agent = this.#agents?.[name];
+    if (!agent) {
+      const error = new chunkB6TOBUS6_cjs.MastraError({
+        id: "MASTRA_GET_AGENT_BY_NAME_NOT_FOUND",
+        domain: "MASTRA" /* MASTRA */,
+        category: "USER" /* USER */,
+        text: `Agent with name ${String(name)} not found`,
+        details: {
+          status: 404,
+          agentName: String(name),
+          agents: Object.keys(this.#agents ?? {}).join(", ")
+        }
+      });
+      this.#logger?.trackException(error);
+      throw error;
+    }
+    return this.#agents[name];
+  }
+  getAgents() {
+    return this.#agents;
+  }
+  getVector(name) {
+    const vector = this.#vectors?.[name];
+    if (!vector) {
+      const error = new chunkB6TOBUS6_cjs.MastraError({
+        id: "MASTRA_GET_VECTOR_BY_NAME_NOT_FOUND",
+        domain: "MASTRA" /* MASTRA */,
+        category: "USER" /* USER */,
+        text: `Vector with name ${String(name)} not found`,
+        details: {
+          status: 404,
+          vectorName: String(name),
+          vectors: Object.keys(this.#vectors ?? {}).join(", ")
+        }
+      });
+      this.#logger?.trackException(error);
+      throw error;
+    }
+    return vector;
+  }
+  getVectors() {
+    return this.#vectors;
+  }
+  getDeployer() {
+    return this.#deployer;
+  }
+  legacy_getWorkflow(id, {
+    serialized
+  } = {}) {
+    const workflow = this.#legacy_workflows?.[id];
+    if (!workflow) {
+      const error = new chunkB6TOBUS6_cjs.MastraError({
+        id: "MASTRA_GET_LEGACY_WORKFLOW_BY_ID_NOT_FOUND",
+        domain: "MASTRA" /* MASTRA */,
+        category: "USER" /* USER */,
+        text: `Workflow with ID ${String(id)} not found`,
+        details: {
+          status: 404,
+          workflowId: String(id),
+          workflows: Object.keys(this.#legacy_workflows ?? {}).join(", ")
+        }
+      });
+      this.#logger?.trackException(error);
+      throw error;
+    }
+    if (serialized) {
+      return {
+        name: workflow.name
+      };
+    }
+    return workflow;
+  }
+  getWorkflow(id, {
+    serialized
+  } = {}) {
+    const workflow = this.#workflows?.[id];
+    if (!workflow) {
+      const error = new chunkB6TOBUS6_cjs.MastraError({
+        id: "MASTRA_GET_WORKFLOW_BY_ID_NOT_FOUND",
+        domain: "MASTRA" /* MASTRA */,
+        category: "USER" /* USER */,
+        text: `Workflow with ID ${String(id)} not found`,
+        details: {
+          status: 404,
+          workflowId: String(id),
+          workflows: Object.keys(this.#workflows ?? {}).join(", ")
+        }
+      });
+      this.#logger?.trackException(error);
+      throw error;
+    }
+    if (serialized) {
+      return {
+        name: workflow.name
+      };
+    }
+    return workflow;
+  }
+  legacy_getWorkflows(props = {}) {
+    if (props.serialized) {
+      return Object.entries(this.#legacy_workflows).reduce((acc, [k, v]) => {
+        return {
+          ...acc,
+          [k]: {
+            name: v.name
+          }
+        };
+      }, {});
+    }
+    return this.#legacy_workflows;
+  }
+  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 = chunkLXFZUKP3_cjs.augmentWithInit(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);
+      });
+    }
+    if (this.#mcpServers) {
+      Object.keys(this.#mcpServers).forEach(key => {
+        this.#mcpServers?.[key]?.__setLogger(this.#logger);
+      });
+    }
+  }
+  setTelemetry(telemetry) {
+    this.#telemetry = chunkQQ5K5TZE_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;
+  }
+  setServerMiddleware(serverMiddleware) {
+    if (typeof serverMiddleware === "function") {
+      this.#serverMiddleware = [{
+        handler: serverMiddleware,
+        path: "/api/*"
+      }];
+      return;
+    }
+    if (!Array.isArray(serverMiddleware)) {
+      const error = new chunkB6TOBUS6_cjs.MastraError({
+        id: "MASTRA_SET_SERVER_MIDDLEWARE_INVALID_TYPE",
+        domain: "MASTRA" /* MASTRA */,
+        category: "USER" /* USER */,
+        text: `Invalid middleware: expected a function or array, received ${typeof serverMiddleware}`
+      });
+      this.#logger?.trackException(error);
+      throw error;
+    }
+    this.#serverMiddleware = serverMiddleware.map(m => {
+      if (typeof m === "function") {
+        return {
+          handler: m,
+          path: "/api/*"
+        };
+      }
+      return {
+        handler: m.handler,
+        path: m.path || "/api/*"
+      };
+    });
+  }
+  getNetworks() {
+    return Object.values(this.#networks || {});
+  }
+  vnext_getNetworks() {
+    return Object.values(this.#vnext_networks || {});
+  }
+  getServer() {
+    return this.#server;
+  }
+  getBundlerConfig() {
+    return this.#bundler;
+  }
+  /**
+   * Get a specific network by ID
+   * @param networkId - The ID of the network to retrieve
+   * @returns The network with the specified ID, or undefined if not found
+   */
+  getNetwork(networkId) {
+    const networks = this.getNetworks();
+    return networks.find(network => {
+      const routingAgent = network.getRoutingAgent();
+      return network.formatAgentId(routingAgent.name) === networkId;
+    });
+  }
+  vnext_getNetwork(networkId) {
+    const networks = this.vnext_getNetworks();
+    return networks.find(network => network.id === networkId);
+  }
+  async getLogsByRunId({
+    runId,
+    transportId,
+    fromDate,
+    toDate,
+    logLevel,
+    filters,
+    page,
+    perPage
+  }) {
+    if (!transportId) {
+      const error = new chunkB6TOBUS6_cjs.MastraError({
+        id: "MASTRA_GET_LOGS_BY_RUN_ID_MISSING_TRANSPORT",
+        domain: "MASTRA" /* MASTRA */,
+        category: "USER" /* USER */,
+        text: "Transport ID is required",
+        details: {
+          runId,
+          transportId
+        }
+      });
+      this.#logger?.trackException(error);
+      throw error;
+    }
+    if (!this.#logger?.getLogsByRunId) {
+      const error = new chunkB6TOBUS6_cjs.MastraError({
+        id: "MASTRA_GET_LOGS_BY_RUN_ID_LOGGER_NOT_CONFIGURED",
+        domain: "MASTRA" /* MASTRA */,
+        category: "SYSTEM" /* SYSTEM */,
+        text: "Logger is not configured or does not support getLogsByRunId operation",
+        details: {
+          runId,
+          transportId
+        }
+      });
+      this.#logger?.trackException(error);
+      throw error;
+    }
+    return await this.#logger.getLogsByRunId({
+      runId,
+      transportId,
+      fromDate,
+      toDate,
+      logLevel,
+      filters,
+      page,
+      perPage
+    });
+  }
+  async getLogs(transportId, params) {
+    if (!transportId) {
+      const error = new chunkB6TOBUS6_cjs.MastraError({
+        id: "MASTRA_GET_LOGS_MISSING_TRANSPORT",
+        domain: "MASTRA" /* MASTRA */,
+        category: "USER" /* USER */,
+        text: "Transport ID is required",
+        details: {
+          transportId
+        }
+      });
+      this.#logger?.trackException(error);
+      throw error;
+    }
+    if (!this.#logger) {
+      const error = new chunkB6TOBUS6_cjs.MastraError({
+        id: "MASTRA_GET_LOGS_LOGGER_NOT_CONFIGURED",
+        domain: "MASTRA" /* MASTRA */,
+        category: "SYSTEM" /* SYSTEM */,
+        text: "Logger is not set",
+        details: {
+          transportId
+        }
+      });
+      throw error;
+    }
+    return await this.#logger.getLogs(transportId, params);
+  }
+  /**
+   * Get all registered MCP server instances.
+   * @returns A record of MCP server ID to MCPServerBase instance, or undefined if none are registered.
+   */
+  getMCPServers() {
+    return this.#mcpServers;
+  }
+  /**
+   * Get a specific MCP server instance.
+   * If a version is provided, it attempts to find the server with that exact logical ID and version.
+   * If no version is provided, it returns the server with the specified logical ID that has the most recent releaseDate.
+   * The logical ID should match the `id` property of the MCPServer instance (typically set via MCPServerConfig.id).
+   * @param serverId - The logical ID of the MCP server to retrieve.
+   * @param version - Optional specific version of the MCP server to retrieve.
+   * @returns The MCP server instance, or undefined if not found or if the specific version is not found.
+   */
+  getMCPServer(serverId, version) {
+    if (!this.#mcpServers) {
+      return void 0;
+    }
+    const allRegisteredServers = Object.values(this.#mcpServers || {});
+    const matchingLogicalIdServers = allRegisteredServers.filter(server => server.id === serverId);
+    if (matchingLogicalIdServers.length === 0) {
+      this.#logger?.debug(`No MCP servers found with logical ID: ${serverId}`);
+      return void 0;
+    }
+    if (version) {
+      const specificVersionServer = matchingLogicalIdServers.find(server => server.version === version);
+      if (!specificVersionServer) {
+        this.#logger?.debug(`MCP server with logical ID '${serverId}' found, but not version '${version}'.`);
+      }
+      return specificVersionServer;
+    } else {
+      if (matchingLogicalIdServers.length === 1) {
+        return matchingLogicalIdServers[0];
+      }
+      matchingLogicalIdServers.sort((a, b) => {
+        const dateAVal = a.releaseDate && typeof a.releaseDate === "string" ? new Date(a.releaseDate).getTime() : NaN;
+        const dateBVal = b.releaseDate && typeof b.releaseDate === "string" ? new Date(b.releaseDate).getTime() : NaN;
+        if (isNaN(dateAVal) && isNaN(dateBVal)) return 0;
+        if (isNaN(dateAVal)) return 1;
+        if (isNaN(dateBVal)) return -1;
+        return dateBVal - dateAVal;
+      });
+      if (matchingLogicalIdServers.length > 0) {
+        const latestServer = matchingLogicalIdServers[0];
+        if (latestServer && latestServer.releaseDate && typeof latestServer.releaseDate === "string" && !isNaN(new Date(latestServer.releaseDate).getTime())) {
+          return latestServer;
+        }
+      }
+      this.#logger?.warn(`Could not determine the latest server for logical ID '${serverId}' due to invalid or missing release dates, or no servers left after filtering.`);
+      return void 0;
+    }
+  }
+};
+exports.Mastra = /*@__PURE__*/(_ => {
+  _init = chunkU64IJDC5_cjs.__decoratorStart(null);
+  exports.Mastra = chunkU64IJDC5_cjs.__decorateElement(_init, 0, "Mastra", _Mastra_decorators, exports.Mastra);
+  chunkU64IJDC5_cjs.__runInitializers(_init, 1, exports.Mastra);
+  return exports.Mastra;
+})();

package/dist/chunk-7HZ6NIAF.cjs

@@ -0,0 +1,2 @@
+'use strict';
+