@mastra/core 0.10.13 → 0.10.14

package/dist/chunk-FEYYOBBG.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+var chunkP3Q73CAW_cjs = require('./chunk-P3Q73CAW.cjs');
+var promises = require('fs/promises');
+var dotenv = require('dotenv');
+
+var MastraBundler = class extends chunkP3Q73CAW_cjs.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;
+  }
+};
+
+exports.MastraBundler = MastraBundler;

package/dist/chunk-FL5SZ2XU.js

@@ -0,0 +1,181 @@
+import { TABLE_WORKFLOW_SNAPSHOT, TABLE_EVALS, TABLE_MESSAGES, TABLE_THREADS, TABLE_TRACES, TABLE_SCHEMAS, TABLE_RESOURCES } from './chunk-TC2SCOTE.js';
+import { MastraBase } from './chunk-5IEKR756.js';
+
+// src/storage/base.ts
+var MastraStorage = class extends MastraBase {
+  /** @deprecated import from { TABLE_WORKFLOW_SNAPSHOT } '@mastra/core/storage' instead */
+  static TABLE_WORKFLOW_SNAPSHOT = TABLE_WORKFLOW_SNAPSHOT;
+  /** @deprecated import from { TABLE_EVALS } '@mastra/core/storage' instead */
+  static TABLE_EVALS = TABLE_EVALS;
+  /** @deprecated import from { TABLE_MESSAGES } '@mastra/core/storage' instead */
+  static TABLE_MESSAGES = TABLE_MESSAGES;
+  /** @deprecated import from { TABLE_THREADS } '@mastra/core/storage' instead */
+  static TABLE_THREADS = TABLE_THREADS;
+  /** @deprecated import { TABLE_TRACES } from '@mastra/core/storage' instead */
+  static TABLE_TRACES = TABLE_TRACES;
+  hasInitialized = null;
+  shouldCacheInit = true;
+  constructor({ name }) {
+    super({
+      component: "STORAGE",
+      name
+    });
+  }
+  get supports() {
+    return {
+      selectByIncludeResourceScope: false,
+      resourceWorkingMemory: false
+    };
+  }
+  ensureDate(date) {
+    if (!date) return void 0;
+    return date instanceof Date ? date : new Date(date);
+  }
+  serializeDate(date) {
+    if (!date) return void 0;
+    const dateObj = this.ensureDate(date);
+    return dateObj?.toISOString();
+  }
+  /**
+   * Resolves limit for how many messages to fetch
+   *
+   * @param last The number of messages to fetch
+   * @param defaultLimit The default limit to use if last is not provided
+   * @returns The resolved limit
+   */
+  resolveMessageLimit({
+    last,
+    defaultLimit
+  }) {
+    if (typeof last === "number") return Math.max(0, last);
+    if (last === false) return 0;
+    return defaultLimit;
+  }
+  getSqlType(type) {
+    switch (type) {
+      case "text":
+        return "TEXT";
+      case "timestamp":
+        return "TIMESTAMP";
+      case "integer":
+        return "INTEGER";
+      case "bigint":
+        return "BIGINT";
+      case "jsonb":
+        return "JSONB";
+      default:
+        return "TEXT";
+    }
+  }
+  getDefaultValue(type) {
+    switch (type) {
+      case "text":
+      case "uuid":
+        return "DEFAULT ''";
+      case "timestamp":
+        return "DEFAULT '1970-01-01 00:00:00'";
+      case "integer":
+      case "bigint":
+        return "DEFAULT 0";
+      case "jsonb":
+        return "DEFAULT '{}'";
+      default:
+        return "DEFAULT ''";
+    }
+  }
+  batchTraceInsert({ records }) {
+    return this.batchInsert({ tableName: TABLE_TRACES, records });
+  }
+  async getResourceById(_) {
+    throw new Error(
+      `Resource working memory is not supported by this storage adapter (${this.constructor.name}). Supported storage adapters: LibSQL (@mastra/libsql), PostgreSQL (@mastra/pg), Upstash (@mastra/upstash). To use per-resource working memory, switch to one of these supported storage adapters.`
+    );
+  }
+  async saveResource(_) {
+    throw new Error(
+      `Resource working memory is not supported by this storage adapter (${this.constructor.name}). Supported storage adapters: LibSQL (@mastra/libsql), PostgreSQL (@mastra/pg), Upstash (@mastra/upstash). To use per-resource working memory, switch to one of these supported storage adapters.`
+    );
+  }
+  async updateResource(_) {
+    throw new Error(
+      `Resource working memory is not supported by this storage adapter (${this.constructor.name}). Supported storage adapters: LibSQL (@mastra/libsql), PostgreSQL (@mastra/pg), Upstash (@mastra/upstash). To use per-resource working memory, switch to one of these supported storage adapters.`
+    );
+  }
+  async init() {
+    if (this.shouldCacheInit && await this.hasInitialized) {
+      return;
+    }
+    const tableCreationTasks = [
+      this.createTable({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        schema: TABLE_SCHEMAS[TABLE_WORKFLOW_SNAPSHOT]
+      }),
+      this.createTable({
+        tableName: TABLE_EVALS,
+        schema: TABLE_SCHEMAS[TABLE_EVALS]
+      }),
+      this.createTable({
+        tableName: TABLE_THREADS,
+        schema: TABLE_SCHEMAS[TABLE_THREADS]
+      }),
+      this.createTable({
+        tableName: TABLE_MESSAGES,
+        schema: TABLE_SCHEMAS[TABLE_MESSAGES]
+      }),
+      this.createTable({
+        tableName: TABLE_TRACES,
+        schema: TABLE_SCHEMAS[TABLE_TRACES]
+      })
+    ];
+    if (this.supports.resourceWorkingMemory) {
+      tableCreationTasks.push(
+        this.createTable({
+          tableName: TABLE_RESOURCES,
+          schema: TABLE_SCHEMAS[TABLE_RESOURCES]
+        })
+      );
+    }
+    this.hasInitialized = Promise.all(tableCreationTasks).then(() => true);
+    await this.hasInitialized;
+    await this?.alterTable?.({
+      tableName: TABLE_MESSAGES,
+      schema: TABLE_SCHEMAS[TABLE_MESSAGES],
+      ifNotExists: ["resourceId"]
+    });
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    await this.init();
+    const data = {
+      workflow_name: workflowName,
+      run_id: runId,
+      snapshot,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.logger.debug("Persisting workflow snapshot", { workflowName, runId, data });
+    await this.insert({
+      tableName: TABLE_WORKFLOW_SNAPSHOT,
+      record: data
+    });
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    if (!this.hasInitialized) {
+      await this.init();
+    }
+    this.logger.debug("Loading workflow snapshot", { workflowName, runId });
+    const d = await this.load({
+      tableName: TABLE_WORKFLOW_SNAPSHOT,
+      keys: { workflow_name: workflowName, run_id: runId }
+    });
+    return d ? d.snapshot : null;
+  }
+};
+
+export { MastraStorage };

package/dist/chunk-GH2KM66J.js

@@ -0,0 +1,37 @@
+import { InstrumentClass } from './chunk-TC2SCOTE.js';
+import { MastraBase } from './chunk-5IEKR756.js';
+import { __decoratorStart, __decorateElement, __runInitializers } from './chunk-WQNOATKB.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-GWFS5DAR.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var chunkQQ5K5TZE_cjs = require('./chunk-QQ5K5TZE.cjs');
+var chunkP3Q73CAW_cjs = require('./chunk-P3Q73CAW.cjs');
+var chunkU64IJDC5_cjs = require('./chunk-U64IJDC5.cjs');
+
+// src/tts/index.ts
+var _MastraTTS_decorators, _init, _a;
+_MastraTTS_decorators = [chunkQQ5K5TZE_cjs.InstrumentClass({
+  prefix: "tts",
+  excludeMethods: ["__setTools", "__setLogger", "__setTelemetry", "#log"]
+})];
+exports.MastraTTS = class MastraTTS extends (_a = chunkP3Q73CAW_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 = chunkU64IJDC5_cjs.__decoratorStart(_a);
+  exports.MastraTTS = chunkU64IJDC5_cjs.__decorateElement(_init, 0, "MastraTTS", _MastraTTS_decorators, exports.MastraTTS);
+  chunkU64IJDC5_cjs.__runInitializers(_init, 1, exports.MastraTTS);
+  return exports.MastraTTS;
+})();

package/dist/chunk-HNEE7IF4.js

@@ -0,0 +1,60 @@
+import { simulateReadableStream } from 'ai';
+import { MockLanguageModelV1 } from 'ai/test';
+
+// src/llm/model/mock.ts
+function createMockModel({
+  objectGenerationMode,
+  mockText,
+  spyGenerate,
+  spyStream
+}) {
+  const mockModel = new MockLanguageModelV1({
+    defaultObjectGenerationMode: objectGenerationMode,
+    doGenerate: async (props) => {
+      if (spyGenerate) {
+        spyGenerate(props);
+      }
+      if (objectGenerationMode === "json") {
+        return {
+          rawCall: { rawPrompt: null, rawSettings: {} },
+          finishReason: "stop",
+          usage: { promptTokens: 10, completionTokens: 20 },
+          text: JSON.stringify(mockText)
+        };
+      }
+      return {
+        rawCall: { rawPrompt: null, rawSettings: {} },
+        finishReason: "stop",
+        usage: { promptTokens: 10, completionTokens: 20 },
+        text: typeof mockText === "string" ? mockText : JSON.stringify(mockText)
+      };
+    },
+    doStream: async (props) => {
+      if (spyStream) {
+        spyStream(props);
+      }
+      const text = typeof mockText === "string" ? mockText : JSON.stringify(mockText);
+      const chunks = text.split(" ").map((word) => ({
+        type: "text-delta",
+        textDelta: word + " "
+      }));
+      return {
+        stream: simulateReadableStream({
+          chunks: [
+            ...chunks,
+            {
+              type: "finish",
+              finishReason: "stop",
+              logprobs: void 0,
+              usage: { completionTokens: 10, promptTokens: 3 }
+            }
+          ]
+        }),
+        rawCall: { rawPrompt: null, rawSettings: {} }
+      };
+    }
+  });
+  return mockModel;
+}
+
+export { createMockModel };

package/dist/chunk-HSVOEWAM.cjs

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

package/dist/chunk-J52TXHZV.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+var chunkST5RMVLG_cjs = require('./chunk-ST5RMVLG.cjs');
+var chunkB6TOBUS6_cjs = require('./chunk-B6TOBUS6.cjs');
+
+// 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();
+  let metricResult;
+  let metricName = metric.constructor.name;
+  try {
+    metricResult = await metric.measure(input.toString(), output);
+  } catch (e) {
+    throw new chunkB6TOBUS6_cjs.MastraError(
+      {
+        id: "EVAL_METRIC_MEASURE_EXECUTION_FAILED",
+        domain: "EVAL" /* EVAL */,
+        category: "USER" /* USER */,
+        details: {
+          agentName,
+          metricName,
+          globalRunId
+        }
+      },
+      e
+    );
+  }
+  const traceObject = {
+    input: input.toString(),
+    output,
+    result: metricResult,
+    agentName,
+    metricName,
+    instructions,
+    globalRunId,
+    runId: runIdToUse,
+    testInfo
+  };
+  try {
+    chunkST5RMVLG_cjs.executeHook("onEvaluation" /* ON_EVALUATION */, traceObject);
+  } catch (e) {
+    throw new chunkB6TOBUS6_cjs.MastraError(
+      {
+        id: "EVAL_HOOK_EXECUTION_FAILED",
+        domain: "EVAL" /* EVAL */,
+        category: "USER" /* USER */,
+        details: {
+          agentName,
+          metricName,
+          globalRunId
+        }
+      },
+      e
+    );
+  }
+  return { ...metricResult, output };
+}
+
+exports.Metric = Metric;
+exports.evaluate = evaluate;

package/dist/chunk-JNMQKJH4.js

@@ -0,0 +1,10 @@
+import { MastraBundler } from './chunk-ATXBSEFT.js';
+
+// src/deployer/index.ts
+var MastraDeployer = class extends MastraBundler {
+  constructor({ name }) {
+    super({ component: "DEPLOYER", name });
+  }
+};
+
+export { MastraDeployer };

package/dist/chunk-JQOMTERC.js

@@ -0,0 +1,89 @@
+import { Transform } from 'stream';
+
+// src/logger/multi-logger.ts
+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));
+  }
+  trackException(error) {
+    this.loggers.forEach((logger) => logger.trackException(error));
+  }
+  getTransports() {
+    const transports = [];
+    this.loggers.forEach((logger) => transports.push(...logger.getTransports().entries()));
+    return new Map(transports);
+  }
+  async getLogs(transportId, params) {
+    for (const logger of this.loggers) {
+      const logs = await logger.getLogs(transportId, params);
+      if (logs.total > 0) {
+        return logs;
+      }
+    }
+    return { logs: [], total: 0, page: params?.page ?? 1, perPage: params?.perPage ?? 100, hasMore: false };
+  }
+  async getLogsByRunId(args) {
+    for (const logger of this.loggers) {
+      const logs = await logger.getLogsByRunId(args);
+      if (logs.total > 0) {
+        return logs;
+      }
+    }
+    return { logs: [], total: 0, page: args.page ?? 1, perPage: args.perPage ?? 100, hasMore: false };
+  }
+};
+
+// src/logger/noop-logger.ts
+var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  },
+  cleanup: async () => {
+  },
+  getTransports: () => /* @__PURE__ */ new Map(),
+  trackException: () => {
+  },
+  getLogs: async () => ({ logs: [], total: 0, page: 1, perPage: 100, hasMore: false }),
+  getLogsByRunId: async () => ({ logs: [], total: 0, page: 1, perPage: 100, hasMore: false })
+};
+var LoggerTransport = class extends Transform {
+  constructor(opts = {}) {
+    super({ ...opts, objectMode: true });
+  }
+  async getLogsByRunId(_args) {
+    return { logs: [], total: 0, page: _args?.page ?? 1, perPage: _args?.perPage ?? 100, hasMore: false };
+  }
+  async getLogs(_args) {
+    return { logs: [], total: 0, page: _args?.page ?? 1, perPage: _args?.perPage ?? 100, hasMore: false };
+  }
+};
+var createCustomTransport = (stream, getLogs, getLogsByRunId) => {
+  let transport = stream;
+  if (getLogs) {
+    transport.getLogs = getLogs;
+  }
+  if (getLogsByRunId) {
+    transport.getLogsByRunId = getLogsByRunId;
+  }
+  return transport;
+};
+
+export { LoggerTransport, MultiLogger, createCustomTransport, noopLogger };

package/dist/chunk-LABUWBKX.cjs

@@ -0,0 +1,71 @@
+'use strict';
+
+// src/runtime-context/index.ts
+var RuntimeContext = class {
+  registry = /* @__PURE__ */ new Map();
+  constructor(iterable) {
+    this.registry = new Map(iterable);
+  }
+  /**
+   * set a value with strict typing if `Values` is a Record and the key exists in it.
+   */
+  set(key, value) {
+    this.registry.set(key, value);
+  }
+  /**
+   * Get a value with its type
+   */
+  get(key) {
+    return this.registry.get(key);
+  }
+  /**
+   * Check if a key exists in the container
+   */
+  has(key) {
+    return this.registry.has(key);
+  }
+  /**
+   * Delete a value by key
+   */
+  delete(key) {
+    return this.registry.delete(key);
+  }
+  /**
+   * Clear all values from the container
+   */
+  clear() {
+    this.registry.clear();
+  }
+  /**
+   * Get all keys in the container
+   */
+  keys() {
+    return this.registry.keys();
+  }
+  /**
+   * Get all values in the container
+   */
+  values() {
+    return this.registry.values();
+  }
+  /**
+   * Get all entries in the container
+   */
+  entries() {
+    return this.registry.entries();
+  }
+  /**
+   * Get the size of the container
+   */
+  size() {
+    return this.registry.size;
+  }
+  /**
+   * Execute a function for each entry in the container
+   */
+  forEach(callbackfn) {
+    this.registry.forEach(callbackfn);
+  }
+};
+
+exports.RuntimeContext = RuntimeContext;

package/dist/chunk-LXFZUKP3.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+// 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) {
+      if (prop === isAugmentedSymbol) {
+        return true;
+      }
+      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);
+    }
+  });
+  return proxy;
+}
+
+exports.augmentWithInit = augmentWithInit;

package/dist/chunk-MP2QBLUJ.cjs

@@ -0,0 +1,70 @@
+'use strict';
+
+var chunkB6TOBUS6_cjs = require('./chunk-B6TOBUS6.cjs');
+var chunkP3Q73CAW_cjs = require('./chunk-P3Q73CAW.cjs');
+
+// src/vector/vector.ts
+var MastraVector = class extends chunkP3Q73CAW_cjs.MastraBase {
+  constructor() {
+    super({ name: "MastraVector", component: "VECTOR" });
+  }
+  get indexSeparator() {
+    return "_";
+  }
+  async validateExistingIndex(indexName, dimension, metric) {
+    let info;
+    try {
+      info = await this.describeIndex({ indexName });
+    } catch (infoError) {
+      const mastraError = new chunkB6TOBUS6_cjs.MastraError(
+        {
+          id: "VECTOR_VALIDATE_INDEX_FETCH_FAILED",
+          text: `Index "${indexName}" already exists, but failed to fetch index info for dimension check.`,
+          domain: "MASTRA_VECTOR" /* MASTRA_VECTOR */,
+          category: "SYSTEM" /* SYSTEM */,
+          details: { indexName }
+        },
+        infoError
+      );
+      this.logger?.trackException(mastraError);
+      this.logger?.error(mastraError.toString());
+      throw mastraError;
+    }
+    const existingDim = info?.dimension;
+    const existingMetric = info?.metric;
+    if (existingDim === dimension) {
+      this.logger?.info(
+        `Index "${indexName}" already exists with ${existingDim} dimensions and metric ${existingMetric}, skipping creation.`
+      );
+      if (existingMetric !== metric) {
+        this.logger?.warn(
+          `Attempted to create index with metric "${metric}", but index already exists with metric "${existingMetric}". To use a different metric, delete and recreate the index.`
+        );
+      }
+    } else if (info) {
+      const mastraError = new chunkB6TOBUS6_cjs.MastraError({
+        id: "VECTOR_VALIDATE_INDEX_DIMENSION_MISMATCH",
+        text: `Index "${indexName}" already exists with ${existingDim} dimensions, but ${dimension} dimensions were requested`,
+        domain: "MASTRA_VECTOR" /* MASTRA_VECTOR */,
+        category: "USER" /* USER */,
+        details: { indexName, existingDim, requestedDim: dimension }
+      });
+      this.logger?.trackException(mastraError);
+      this.logger?.error(mastraError.toString());
+      throw mastraError;
+    } else {
+      const mastraError = new chunkB6TOBUS6_cjs.MastraError({
+        id: "VECTOR_VALIDATE_INDEX_NO_DIMENSION",
+        text: `Index "${indexName}" already exists, but could not retrieve its dimensions for validation.`,
+        domain: "MASTRA_VECTOR" /* MASTRA_VECTOR */,
+        category: "SYSTEM" /* SYSTEM */,
+        details: { indexName }
+      });
+      this.logger?.trackException(mastraError);
+      this.logger?.error(mastraError.toString());
+      throw mastraError;
+    }
+  }
+};
+
+exports.MastraVector = MastraVector;