@mastra/core 0.5.0-alpha.8 → 0.5.0

package/dist/mastra/index.cjs

@@ -1,1762 +1,10 @@
 'use strict';
 
-var stream = require('stream');
-var pino = require('pino');
-var pretty = require('pino-pretty');
-var path = require('path');
-var client = require('@libsql/client');
-var api = require('@opentelemetry/api');
-var core = require('@opentelemetry/core');
-var otlpTransformer = require('@opentelemetry/otlp-transformer');
+var chunkGXQRMKSN_cjs = require('../chunk-GXQRMKSN.cjs');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var pino__default = /*#__PURE__*/_interopDefault(pino);
-var pretty__default = /*#__PURE__*/_interopDefault(pretty);
 
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-var __typeError = msg => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
+Object.defineProperty(exports, "Mastra", {
   enumerable: true,
-  configurable: true,
-  writable: true,
-  value
-}) : obj[key] = value;
-var __name = (target, value) => __defProp(target, "name", {
-  value,
-  configurable: true
+  get: function () { return chunkGXQRMKSN_cjs.Mastra; }
 });
-var __decoratorStart = base => [,,, __create(null)];
-var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
-var __expectFn = fn => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
-var __decoratorContext = (kind, name, done, metadata, fns) => ({
-  kind: __decoratorStrings[kind],
-  name,
-  metadata,
-  addInitializer: fn => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
-});
-var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
-var __runInitializers = (array, flags, self, value) => {
-  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self) ;
-  return value;
-};
-var __decorateElement = (array, flags, name, decorators, target, extra) => {
-  var it,
-    done,
-    ctx,
-    k = flags & 7,
-    p = false;
-  var j = 0;
-  var extraInitializers = array[j] || (array[j] = []);
-  var desc = k && ((target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(target , name));
-  __name(target, name);
-  for (var i = decorators.length - 1; i >= 0; i--) {
-    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
-    it = (0, decorators[i])(target, ctx), done._ = 1;
-    __expectFn(it) && (target = it);
-  }
-  return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
-};
-var RegisteredLogger = {
-  LLM: "LLM"};
-var LogLevel = {
-  INFO: "info",
-  WARN: "warn"};
-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,
-      formatters: {
-        level: label => {
-          return {
-            level: label
-          };
-        }
-      }
-    }, 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);
-}
-var noopLogger = {
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-  cleanup: async () => {}
-};
-
-// 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/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";
-
-// 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
-    });
-  }
-  async __batchInsert({
-    tableName,
-    records
-  }) {
-    await this.init();
-    return this.batchInsert({
-      tableName,
-      records
-    });
-  }
-  async __getThreadById({
-    threadId
-  }) {
-    await this.init();
-    return this.getThreadById({
-      threadId
-    });
-  }
-  async __getThreadsByResourceId({
-    resourceId
-  }) {
-    await this.init();
-    return this.getThreadsByResourceId({
-      resourceId
-    });
-  }
-  async __saveThread({
-    thread
-  }) {
-    await this.init();
-    return this.saveThread({
-      thread
-    });
-  }
-  async __updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    await this.init();
-    return this.updateThread({
-      id,
-      title,
-      metadata
-    });
-  }
-  async __deleteThread({
-    threadId
-  }) {
-    await this.init();
-    return this.deleteThread({
-      threadId
-    });
-  }
-  async __getMessages({
-    threadId,
-    selectBy,
-    threadConfig
-  }) {
-    await this.init();
-    return this.getMessages({
-      threadId,
-      selectBy,
-      threadConfig
-    });
-  }
-  async __saveMessages({
-    messages
-  }) {
-    await this.init();
-    return this.saveMessages({
-      messages
-    });
-  }
-  async __getTraces({
-    scope,
-    page,
-    perPage,
-    attributes
-  }) {
-    await this.init();
-    return this.getTraces({
-      scope,
-      page,
-      perPage,
-      attributes
-    });
-  }
-  async init() {
-    if (this.shouldCacheInit && (await this.hasInitialized)) {
-      return;
-    }
-    this.hasInitialized = Promise.all([this.createTable({
-      tableName: TABLE_WORKFLOW_SNAPSHOT,
-      schema: {
-        workflow_name: {
-          type: "text"
-        },
-        run_id: {
-          type: "text"
-        },
-        snapshot: {
-          type: "text"
-        },
-        createdAt: {
-          type: "timestamp"
-        },
-        updatedAt: {
-          type: "timestamp"
-        }
-      }
-    }), this.createTable({
-      tableName: TABLE_EVALS,
-      schema: {
-        input: {
-          type: "text"
-        },
-        output: {
-          type: "text"
-        },
-        result: {
-          type: "jsonb"
-        },
-        agent_name: {
-          type: "text"
-        },
-        metric_name: {
-          type: "text"
-        },
-        instructions: {
-          type: "text"
-        },
-        test_info: {
-          type: "jsonb",
-          nullable: true
-        },
-        global_run_id: {
-          type: "text"
-        },
-        run_id: {
-          type: "text"
-        },
-        created_at: {
-          type: "timestamp"
-        }
-      }
-    }), this.createTable({
-      tableName: TABLE_THREADS,
-      schema: {
-        id: {
-          type: "text",
-          nullable: false,
-          primaryKey: true
-        },
-        resourceId: {
-          type: "text",
-          nullable: false
-        },
-        title: {
-          type: "text",
-          nullable: false
-        },
-        metadata: {
-          type: "text",
-          nullable: true
-        },
-        createdAt: {
-          type: "timestamp",
-          nullable: false
-        },
-        updatedAt: {
-          type: "timestamp",
-          nullable: false
-        }
-      }
-    }), this.createTable({
-      tableName: TABLE_MESSAGES,
-      schema: {
-        id: {
-          type: "text",
-          nullable: false,
-          primaryKey: true
-        },
-        thread_id: {
-          type: "text",
-          nullable: false
-        },
-        content: {
-          type: "text",
-          nullable: false
-        },
-        role: {
-          type: "text",
-          nullable: false
-        },
-        type: {
-          type: "text",
-          nullable: false
-        },
-        createdAt: {
-          type: "timestamp",
-          nullable: false
-        }
-      }
-    }), this.createTable({
-      tableName: TABLE_TRACES,
-      schema: {
-        id: {
-          type: "text",
-          nullable: false,
-          primaryKey: true
-        },
-        parentSpanId: {
-          type: "text",
-          nullable: true
-        },
-        name: {
-          type: "text",
-          nullable: false
-        },
-        traceId: {
-          type: "text",
-          nullable: false
-        },
-        scope: {
-          type: "text",
-          nullable: false
-        },
-        kind: {
-          type: "integer",
-          nullable: false
-        },
-        attributes: {
-          type: "jsonb",
-          nullable: true
-        },
-        status: {
-          type: "jsonb",
-          nullable: true
-        },
-        events: {
-          type: "jsonb",
-          nullable: true
-        },
-        links: {
-          type: "jsonb",
-          nullable: true
-        },
-        other: {
-          type: "text",
-          nullable: true
-        },
-        startTime: {
-          type: "bigint",
-          nullable: false
-        },
-        endTime: {
-          type: "bigint",
-          nullable: false
-        },
-        createdAt: {
-          type: "timestamp",
-          nullable: false
-        }
-      }
-    })]).then(() => true);
-    await this.hasInitialized;
-  }
-  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;
-  }
-  async __getEvalsByAgentName(agentName, type) {
-    await this.init();
-    return this.getEvalsByAgentName(agentName, type);
-  }
-};
-
-// src/storage/libsql/index.ts
-function safelyParseJSON(jsonString) {
-  try {
-    return JSON.parse(jsonString);
-  } catch {
-    return {};
-  }
-}
-var LibSQLStore = class extends MastraStorage {
-  client;
-  constructor({
-    config
-  }) {
-    super({
-      name: `LibSQLStore`
-    });
-    if (config.url === ":memory:") {
-      this.shouldCacheInit = false;
-    }
-    this.client = client.createClient({
-      url: this.rewriteDbUrl(config.url),
-      authToken: config.authToken
-    });
-  }
-  // If we're in the .mastra/output directory, use the dir outside .mastra dir
-  // reason we need to do this is libsql relative file paths are based on cwd, not current file path
-  // since mastra dev sets cwd to .mastra/output this means running an agent directly vs running with mastra dev
-  // will put db files in different locations, leading to an inconsistent experience between the two.
-  // Ex: with `file:ex.db`
-  // 1. `mastra dev`: ${cwd}/.mastra/output/ex.db
-  // 2. `tsx src/index.ts`: ${cwd}/ex.db
-  // so if we're in .mastra/output we need to rewrite the file url to be relative to the project root dir
-  // or the experience will be inconsistent
-  // this means `file:` urls are always relative to project root
-  // TODO: can we make this easier via bundling? https://github.com/mastra-ai/mastra/pull/2783#pullrequestreview-2662444241
-  rewriteDbUrl(url) {
-    if (url.startsWith("file:")) {
-      const pathPart = url.slice("file:".length);
-      if (path.isAbsolute(pathPart)) {
-        return url;
-      }
-      const cwd = process.cwd();
-      if (cwd.includes(".mastra") && (cwd.endsWith(`output`) || cwd.endsWith(`output/`) || cwd.endsWith(`output\\`))) {
-        const baseDir = path.join(cwd, `..`, `..`);
-        const fullPath = path.resolve(baseDir, pathPart);
-        this.logger.debug(`Initializing LibSQL db with url ${url} with relative file path from inside .mastra/output directory. Rewriting relative file url to "file:${fullPath}". This ensures it's outside the .mastra/output directory.`);
-        return `file:${fullPath}`;
-      }
-    }
-    return url;
-  }
-  getCreateTableSQL(tableName, schema) {
-    const columns = Object.entries(schema).map(([name, col]) => {
-      let type = col.type.toUpperCase();
-      if (type === "TEXT") type = "TEXT";
-      if (type === "TIMESTAMP") type = "TEXT";
-      const nullable = col.nullable ? "" : "NOT NULL";
-      const primaryKey = col.primaryKey ? "PRIMARY KEY" : "";
-      return `${name} ${type} ${nullable} ${primaryKey}`.trim();
-    });
-    if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
-      const stmnt = `CREATE TABLE IF NOT EXISTS ${tableName} (
-                ${columns.join(",\n")},
-                PRIMARY KEY (workflow_name, run_id)
-            )`;
-      return stmnt;
-    }
-    return `CREATE TABLE IF NOT EXISTS ${tableName} (${columns.join(", ")})`;
-  }
-  async createTable({
-    tableName,
-    schema
-  }) {
-    try {
-      this.logger.debug(`Creating database table`, {
-        tableName,
-        operation: "schema init"
-      });
-      const sql = this.getCreateTableSQL(tableName, schema);
-      await this.client.execute(sql);
-    } catch (error) {
-      this.logger.error(`Error creating table ${tableName}: ${error}`);
-      throw error;
-    }
-  }
-  async clearTable({
-    tableName
-  }) {
-    try {
-      await this.client.execute(`DELETE FROM ${tableName}`);
-    } catch (e) {
-      if (e instanceof Error) {
-        this.logger.error(e.message);
-      }
-    }
-  }
-  prepareStatement({
-    tableName,
-    record
-  }) {
-    const columns = Object.keys(record);
-    const values = Object.values(record).map(v => {
-      if (typeof v === `undefined`) {
-        return null;
-      }
-      if (v instanceof Date) {
-        return v.toISOString();
-      }
-      return typeof v === "object" ? JSON.stringify(v) : v;
-    });
-    const placeholders = values.map(() => "?").join(", ");
-    return {
-      sql: `INSERT OR REPLACE INTO ${tableName} (${columns.join(", ")}) VALUES (${placeholders})`,
-      args: values
-    };
-  }
-  async insert({
-    tableName,
-    record
-  }) {
-    try {
-      await this.client.execute(this.prepareStatement({
-        tableName,
-        record
-      }));
-    } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
-    }
-  }
-  async batchInsert({
-    tableName,
-    records
-  }) {
-    if (records.length === 0) return;
-    try {
-      const batchStatements = records.map(r => this.prepareStatement({
-        tableName,
-        record: r
-      }));
-      await this.client.batch(batchStatements, "write");
-    } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
-    }
-  }
-  async load({
-    tableName,
-    keys
-  }) {
-    const conditions = Object.entries(keys).map(([key]) => `${key} = ?`).join(" AND ");
-    const values = Object.values(keys);
-    const result = await this.client.execute({
-      sql: `SELECT * FROM ${tableName} WHERE ${conditions} ORDER BY createdAt DESC LIMIT 1`,
-      args: values
-    });
-    if (!result.rows || result.rows.length === 0) {
-      return null;
-    }
-    const row = result.rows[0];
-    const parsed = Object.fromEntries(Object.entries(row || {}).map(([k, v]) => {
-      try {
-        return [k, typeof v === "string" ? v.startsWith("{") || v.startsWith("[") ? JSON.parse(v) : v : v];
-      } catch {
-        return [k, v];
-      }
-    }));
-    return parsed;
-  }
-  async getThreadById({
-    threadId
-  }) {
-    const result = await this.load({
-      tableName: TABLE_THREADS,
-      keys: {
-        id: threadId
-      }
-    });
-    if (!result) {
-      return null;
-    }
-    return {
-      ...result,
-      metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
-    };
-  }
-  async getThreadsByResourceId({
-    resourceId
-  }) {
-    const result = await this.client.execute({
-      sql: `SELECT * FROM ${TABLE_THREADS} WHERE resourceId = ?`,
-      args: [resourceId]
-    });
-    if (!result.rows) {
-      return [];
-    }
-    return result.rows.map(thread => ({
-      id: thread.id,
-      resourceId: thread.resourceId,
-      title: thread.title,
-      createdAt: thread.createdAt,
-      updatedAt: thread.updatedAt,
-      metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
-    }));
-  }
-  async saveThread({
-    thread
-  }) {
-    await this.insert({
-      tableName: TABLE_THREADS,
-      record: {
-        ...thread,
-        metadata: JSON.stringify(thread.metadata)
-      }
-    });
-    return thread;
-  }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    const thread = await this.getThreadById({
-      threadId: id
-    });
-    if (!thread) {
-      throw new Error(`Thread ${id} not found`);
-    }
-    const updatedThread = {
-      ...thread,
-      title,
-      metadata: {
-        ...thread.metadata,
-        ...metadata
-      }
-    };
-    await this.client.execute({
-      sql: `UPDATE ${TABLE_THREADS} SET title = ?, metadata = ? WHERE id = ?`,
-      args: [title, JSON.stringify(updatedThread.metadata), id]
-    });
-    return updatedThread;
-  }
-  async deleteThread({
-    threadId
-  }) {
-    await this.client.execute({
-      sql: `DELETE FROM ${TABLE_THREADS} WHERE id = ?`,
-      args: [threadId]
-    });
-  }
-  parseRow(row) {
-    let content = row.content;
-    try {
-      content = JSON.parse(row.content);
-    } catch {}
-    return {
-      id: row.id,
-      content,
-      role: row.role,
-      type: row.type,
-      createdAt: new Date(row.createdAt),
-      threadId: row.thread_id
-    };
-  }
-  async getMessages({
-    threadId,
-    selectBy
-  }) {
-    try {
-      const messages = [];
-      const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
-      if (selectBy?.include?.length) {
-        const includeIds = selectBy.include.map(i => i.id);
-        const maxPrev = Math.max(...selectBy.include.map(i => i.withPreviousMessages || 0));
-        const maxNext = Math.max(...selectBy.include.map(i => i.withNextMessages || 0));
-        const includeResult = await this.client.execute({
-          sql: `
-            WITH numbered_messages AS (
-              SELECT 
-                id,
-                content,
-                role,
-                type,
-                "createdAt",
-                thread_id,
-                ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
-              FROM "${TABLE_MESSAGES}"
-              WHERE thread_id = ?
-            ),
-            target_positions AS (
-              SELECT row_num as target_pos
-              FROM numbered_messages
-              WHERE id IN (${includeIds.map(() => "?").join(", ")})
-            )
-            SELECT DISTINCT m.*
-            FROM numbered_messages m
-            CROSS JOIN target_positions t
-            WHERE m.row_num BETWEEN (t.target_pos - ?) AND (t.target_pos + ?)
-            ORDER BY m."createdAt" ASC
-          `,
-          args: [threadId, ...includeIds, maxPrev, maxNext]
-        });
-        if (includeResult.rows) {
-          messages.push(...includeResult.rows.map(row => this.parseRow(row)));
-        }
-      }
-      const excludeIds = messages.map(m => m.id);
-      const remainingSql = `
-        SELECT 
-          id, 
-          content, 
-          role, 
-          type,
-          "createdAt", 
-          thread_id
-        FROM "${TABLE_MESSAGES}"
-        WHERE thread_id = ?
-        ${excludeIds.length ? `AND id NOT IN (${excludeIds.map(() => "?").join(", ")})` : ""}
-        ORDER BY "createdAt" DESC
-        LIMIT ?
-      `;
-      const remainingArgs = [threadId, ...(excludeIds.length ? excludeIds : []), limit];
-      const remainingResult = await this.client.execute({
-        sql: remainingSql,
-        args: remainingArgs
-      });
-      if (remainingResult.rows) {
-        messages.push(...remainingResult.rows.map(row => this.parseRow(row)));
-      }
-      messages.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-      return messages;
-    } catch (error) {
-      this.logger.error("Error getting messages:", error);
-      throw error;
-    }
-  }
-  async saveMessages({
-    messages
-  }) {
-    if (messages.length === 0) return messages;
-    const tx = await this.client.transaction("write");
-    try {
-      const threadId = messages[0]?.threadId;
-      if (!threadId) {
-        throw new Error("Thread ID is required");
-      }
-      for (const message of messages) {
-        const time = message.createdAt || /* @__PURE__ */new Date();
-        await tx.execute({
-          sql: `INSERT INTO ${TABLE_MESSAGES} (id, thread_id, content, role, type, createdAt) 
-                              VALUES (?, ?, ?, ?, ?, ?)`,
-          args: [message.id, threadId, typeof message.content === "object" ? JSON.stringify(message.content) : message.content, message.role, message.type, time instanceof Date ? time.toISOString() : time]
-        });
-      }
-      await tx.commit();
-      return messages;
-    } catch (error) {
-      this.logger.error("Failed to save messages in database: " + error?.message);
-      await tx.rollback();
-      throw error;
-    }
-  }
-  transformEvalRow(row) {
-    const resultValue = JSON.parse(row.result);
-    const testInfoValue = row.test_info ? JSON.parse(row.test_info) : void 0;
-    if (!resultValue || typeof resultValue !== "object" || !("score" in resultValue)) {
-      throw new Error(`Invalid MetricResult format: ${JSON.stringify(resultValue)}`);
-    }
-    return {
-      input: row.input,
-      output: row.output,
-      result: resultValue,
-      agentName: row.agent_name,
-      metricName: row.metric_name,
-      instructions: row.instructions,
-      testInfo: testInfoValue,
-      globalRunId: row.global_run_id,
-      runId: row.run_id,
-      createdAt: row.created_at
-    };
-  }
-  async getEvalsByAgentName(agentName, type) {
-    try {
-      const baseQuery = `SELECT * FROM ${TABLE_EVALS} WHERE agent_name = ?`;
-      const typeCondition = type === "test" ? " AND test_info IS NOT NULL AND test_info->>'testPath' IS NOT NULL" : type === "live" ? " AND (test_info IS NULL OR test_info->>'testPath' IS NULL)" : "";
-      const result = await this.client.execute({
-        sql: `${baseQuery}${typeCondition} ORDER BY created_at DESC`,
-        args: [agentName]
-      });
-      return result.rows?.map(row => this.transformEvalRow(row)) ?? [];
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("no such table")) {
-        return [];
-      }
-      this.logger.error("Failed to get evals for the specified agent: " + error?.message);
-      throw error;
-    }
-  }
-  // TODO: add types
-  async getTraces({
-    name,
-    scope,
-    page,
-    perPage,
-    attributes
-  } = {
-    page: 0,
-    perPage: 100
-  }) {
-    const limit = perPage;
-    const offset = page * perPage;
-    const args = [];
-    const conditions = [];
-    if (name) {
-      conditions.push("name LIKE CONCAT(?, '%')");
-    }
-    if (scope) {
-      conditions.push("scope = ?");
-    }
-    if (attributes) {
-      Object.keys(attributes).forEach(key => {
-        conditions.push(`attributes->>'$.${key}' = ?`);
-      });
-    }
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    if (name) {
-      args.push(name);
-    }
-    if (scope) {
-      args.push(scope);
-    }
-    if (attributes) {
-      for (const [_key, value] of Object.entries(attributes)) {
-        args.push(value);
-      }
-    }
-    args.push(limit, offset);
-    const result = await this.client.execute({
-      sql: `SELECT * FROM ${TABLE_TRACES} ${whereClause} ORDER BY "startTime" DESC LIMIT ? OFFSET ?`,
-      args
-    });
-    if (!result.rows) {
-      return [];
-    }
-    return result.rows.map(row => ({
-      id: row.id,
-      parentSpanId: row.parentSpanId,
-      traceId: row.traceId,
-      name: row.name,
-      scope: row.scope,
-      kind: row.kind,
-      status: safelyParseJSON(row.status),
-      events: safelyParseJSON(row.events),
-      links: safelyParseJSON(row.links),
-      attributes: safelyParseJSON(row.attributes),
-      startTime: row.startTime,
-      endTime: row.endTime,
-      other: safelyParseJSON(row.other),
-      createdAt: row.createdAt
-    }));
-  }
-};
-function hasActiveTelemetry(tracerName = "default-tracer") {
-  try {
-    return !!api.trace.getTracer(tracerName);
-  } catch {
-    return false;
-  }
-}
-
-// src/telemetry/telemetry.decorators.ts
-function withSpan(options) {
-  return function (_target, propertyKey, descriptor) {
-    if (!descriptor || typeof descriptor === "number") return;
-    const originalMethod = descriptor.value;
-    const methodName = String(propertyKey);
-    descriptor.value = function (...args) {
-      if (options?.skipIfNoTelemetry && !hasActiveTelemetry(options?.tracerName)) {
-        return originalMethod.apply(this, args);
-      }
-      const tracer = api.trace.getTracer(options?.tracerName ?? "default-tracer");
-      let spanName;
-      let spanKind;
-      if (typeof options === "string") {
-        spanName = options;
-      } else if (options) {
-        spanName = options.spanName || methodName;
-        spanKind = options.spanKind;
-      } else {
-        spanName = methodName;
-      }
-      const span = tracer.startSpan(spanName, {
-        kind: spanKind
-      });
-      let ctx = api.trace.setSpan(api.context.active(), span);
-      args.forEach((arg, index) => {
-        try {
-          span.setAttribute(`${spanName}.argument.${index}`, JSON.stringify(arg));
-        } catch {
-          span.setAttribute(`${spanName}.argument.${index}`, "[Not Serializable]");
-        }
-      });
-      const currentBaggage = api.propagation.getBaggage(ctx);
-      if (currentBaggage?.componentName) {
-        span.setAttribute("componentName", currentBaggage?.componentName);
-        span.setAttribute("runId", currentBaggage?.runId);
-      } else if (this && this.name) {
-        span.setAttribute("componentName", this.name);
-        span.setAttribute("runId", this.runId);
-        ctx = api.propagation.setBaggage(ctx, {
-          componentName: this.name,
-          runId: this.runId
-        });
-      }
-      let result;
-      try {
-        result = api.context.with(ctx, () => originalMethod.apply(this, args));
-        if (result instanceof Promise) {
-          return result.then(resolvedValue => {
-            try {
-              span.setAttribute(`${spanName}.result`, JSON.stringify(resolvedValue));
-            } catch {
-              span.setAttribute(`${spanName}.result`, "[Not Serializable]");
-            }
-            return resolvedValue;
-          }).finally(() => span.end());
-        }
-        try {
-          span.setAttribute(`${spanName}.result`, JSON.stringify(result));
-        } catch {
-          span.setAttribute(`${spanName}.result`, "[Not Serializable]");
-        }
-        return result;
-      } catch (error) {
-        span.setStatus({
-          code: api.SpanStatusCode.ERROR,
-          message: error instanceof Error ? error.message : "Unknown error"
-        });
-        if (error instanceof Error) {
-          span.recordException(error);
-        }
-        throw error;
-      } finally {
-        if (!(result instanceof Promise)) {
-          span.end();
-        }
-      }
-    };
-    return descriptor;
-  };
-}
-function InstrumentClass(options) {
-  return function (target) {
-    const methods = Object.getOwnPropertyNames(target.prototype);
-    methods.forEach(method => {
-      if (options?.excludeMethods?.includes(method) || method === "constructor") return;
-      if (options?.methodFilter && !options.methodFilter(method)) return;
-      const descriptor = Object.getOwnPropertyDescriptor(target.prototype, method);
-      if (descriptor && typeof descriptor.value === "function") {
-        Object.defineProperty(target.prototype, method, withSpan({
-          spanName: options?.prefix ? `${options.prefix}.${method}` : method,
-          skipIfNoTelemetry: true,
-          spanKind: options?.spanKind || api.SpanKind.INTERNAL,
-          tracerName: options?.tracerName
-        })(target, method, descriptor));
-      }
-    });
-    return target;
-  };
-}
-var OTLPTraceExporter = class {
-  storage;
-  queue = [];
-  serializer;
-  logger;
-  activeFlush = void 0;
-  constructor({
-    logger,
-    storage
-  }) {
-    this.storage = storage;
-    this.serializer = otlpTransformer.JsonTraceSerializer;
-    this.logger = logger;
-  }
-  export(internalRepresentation, resultCallback) {
-    const serializedRequest = this.serializer.serializeRequest(internalRepresentation);
-    const payload = JSON.parse(Buffer.from(serializedRequest.buffer, "utf8"));
-    const items = payload?.resourceSpans?.[0]?.scopeSpans;
-    this.logger.debug(`Exporting telemetry: ${items.length} scope spans to be processed [trace batch]`);
-    this.queue.push({
-      data: items,
-      resultCallback
-    });
-    if (!this.activeFlush) {
-      this.activeFlush = this.flush();
-    }
-  }
-  shutdown() {
-    return this.forceFlush();
-  }
-  flush() {
-    const now = /* @__PURE__ */new Date();
-    const items = this.queue.shift();
-    if (!items) return Promise.resolve();
-    const allSpans = items.data.reduce((acc, scopedSpans) => {
-      const {
-        scope,
-        spans
-      } = scopedSpans;
-      for (const span of spans) {
-        const {
-          spanId,
-          parentSpanId,
-          traceId,
-          name,
-          kind,
-          attributes,
-          status,
-          events,
-          links,
-          startTimeUnixNano,
-          endTimeUnixNano,
-          ...rest
-        } = span;
-        const startTime = Number(BigInt(startTimeUnixNano) / 1000n);
-        const endTime = Number(BigInt(endTimeUnixNano) / 1000n);
-        acc.push({
-          id: spanId,
-          parentSpanId,
-          traceId,
-          name,
-          scope: scope.name,
-          kind,
-          status: JSON.stringify(status),
-          events: JSON.stringify(events),
-          links: JSON.stringify(links),
-          attributes: JSON.stringify(attributes.reduce((acc2, attr) => {
-            const valueKey = Object.keys(attr.value)[0];
-            if (valueKey) {
-              acc2[attr.key] = attr.value[valueKey];
-            }
-            return acc2;
-          }, {})),
-          startTime,
-          endTime,
-          other: JSON.stringify(rest),
-          createdAt: now
-        });
-      }
-      return acc;
-    }, []);
-    return this.storage.__batchInsert({
-      tableName: TABLE_TRACES,
-      records: allSpans
-    }).then(() => {
-      items.resultCallback({
-        code: core.ExportResultCode.SUCCESS
-      });
-    }).catch(e => {
-      this.logger.error("span err:" + e?.message);
-      items.resultCallback({
-        code: core.ExportResultCode.FAILED,
-        error: e
-      });
-    }).finally(() => {
-      this.activeFlush = void 0;
-    });
-  }
-  async forceFlush() {
-    if (!this.queue.length) {
-      return;
-    }
-    await this.activeFlush;
-    while (this.queue.length) {
-      await this.flush();
-    }
-  }
-  __setLogger(logger) {
-    this.logger = logger;
-  }
-};
-var Telemetry = class _Telemetry {
-  tracer = api.trace.getTracer("default");
-  name = "default-service";
-  constructor(config) {
-    this.name = config.serviceName ?? "default-service";
-    this.tracer = api.trace.getTracer(this.name);
-  }
-  /**
-   * @deprecated This method does not do anything
-   */
-  async shutdown() {}
-  /**
-   * Initialize telemetry with the given configuration
-   * @param config - Optional telemetry configuration object
-   * @returns Telemetry instance that can be used for tracing
-   */
-  static init(config = {}) {
-    try {
-      if (!global.__TELEMETRY__) {
-        global.__TELEMETRY__ = new _Telemetry(config);
-      }
-      return global.__TELEMETRY__;
-    } catch (error) {
-      console.error("Failed to initialize telemetry:", error);
-      throw error;
-    }
-  }
-  /**
-   * Get the global telemetry instance
-   * @throws {Error} If telemetry has not been initialized
-   * @returns {Telemetry} The global telemetry instance
-   */
-  static get() {
-    if (!global.__TELEMETRY__) {
-      throw new Error("Telemetry not initialized");
-    }
-    return global.__TELEMETRY__;
-  }
-  /**
-   * Wraps a class instance with telemetry tracing
-   * @param instance The class instance to wrap
-   * @param options Optional configuration for tracing
-   * @returns Wrapped instance with all methods traced
-   */
-  traceClass(instance, options = {}) {
-    const {
-      skipIfNoTelemetry = true
-    } = options;
-    if (skipIfNoTelemetry && !hasActiveTelemetry()) {
-      return instance;
-    }
-    const {
-      spanNamePrefix = instance.constructor.name.toLowerCase(),
-      attributes = {},
-      excludeMethods = []
-    } = options;
-    return new Proxy(instance, {
-      get: (target, prop) => {
-        const value = target[prop];
-        if (typeof value === "function" && prop !== "constructor" && !prop.toString().startsWith("_") && !excludeMethods.includes(prop.toString())) {
-          return this.traceMethod(value.bind(target), {
-            spanName: `${spanNamePrefix}.${prop.toString()}`,
-            attributes: {
-              ...attributes,
-              [`${spanNamePrefix}.name`]: target.constructor.name,
-              [`${spanNamePrefix}.method.name`]: prop.toString()
-            }
-          });
-        }
-        return value;
-      }
-    });
-  }
-  /**
-   * method to trace individual methods with proper context
-   * @param method The method to trace
-   * @param context Additional context for the trace
-   * @returns Wrapped method with tracing
-   */
-  traceMethod(method, context3) {
-    let ctx = api.context.active();
-    const {
-      skipIfNoTelemetry = true
-    } = context3;
-    if (skipIfNoTelemetry && !hasActiveTelemetry()) {
-      return method;
-    }
-    return (...args) => {
-      const span = this.tracer.startSpan(context3.spanName);
-      function handleError(error) {
-        span.recordException(error);
-        span.setStatus({
-          code: api.SpanStatusCode.ERROR,
-          message: error.message
-        });
-        span.end();
-        throw error;
-      }
-      try {
-        let recordResult2 = function (res) {
-          try {
-            span.setAttribute(`${context3.spanName}.result`, JSON.stringify(res));
-          } catch {
-            span.setAttribute(`${context3.spanName}.result`, "[Not Serializable]");
-          }
-          span.end();
-          return res;
-        };
-        if (context3.attributes) {
-          span.setAttributes(context3.attributes);
-        }
-        if (context3.attributes?.componentName) {
-          ctx = api.propagation.setBaggage(ctx, {
-            // @ts-ignore
-            componentName: context3.attributes.componentName,
-            runId: context3.attributes.runId
-          });
-        } else {
-          const currentBaggage = api.propagation.getBaggage(ctx);
-          if (currentBaggage?.componentName) {
-            span.setAttribute("componentName", currentBaggage?.componentName);
-            span.setAttribute("runId", currentBaggage?.runId);
-          } else if (this && this.name) {
-            span.setAttribute("componentName", this.name);
-            span.setAttribute("runId", this.runId);
-            ctx = api.propagation.setBaggage(ctx, {
-              componentName: this.name,
-              runId: this.runId
-            });
-          }
-        }
-        args.forEach((arg, index) => {
-          try {
-            span.setAttribute(`${context3.spanName}.argument.${index}`, JSON.stringify(arg));
-          } catch {
-            span.setAttribute(`${context3.spanName}.argument.${index}`, "[Not Serializable]");
-          }
-        });
-        let result;
-        api.context.with(api.trace.setSpan(ctx, span), () => {
-          result = method(...args);
-        });
-        if (result instanceof Promise) {
-          return result.then(recordResult2).catch(handleError);
-        } else {
-          return recordResult2(result);
-        }
-      } catch (error) {
-        handleError(error);
-      }
-    };
-  }
-  getBaggageTracer() {
-    return new BaggageTracer(this.tracer);
-  }
-};
-var BaggageTracer = class {
-  _tracer;
-  constructor(tracer) {
-    this._tracer = tracer;
-  }
-  startSpan(name, options = {}, ctx) {
-    ctx = ctx ?? api.context.active();
-    const span = this._tracer.startSpan(name, options, ctx);
-    const currentBaggage = api.propagation.getBaggage(ctx);
-    span.setAttribute("componentName", currentBaggage?.componentName);
-    span.setAttribute("runId", currentBaggage?.runId);
-    return span;
-  }
-  startActiveSpan(name, optionsOrFn, ctxOrFn, fn) {
-    if (typeof optionsOrFn === "function") {
-      const wrappedFn2 = span => {
-        const currentBaggage = api.propagation.getBaggage(api.context.active());
-        span.setAttribute("componentName", currentBaggage?.componentName);
-        return optionsOrFn(span);
-      };
-      return this._tracer.startActiveSpan(name, {}, api.context.active(), wrappedFn2);
-    }
-    if (typeof ctxOrFn === "function") {
-      const wrappedFn2 = span => {
-        const currentBaggage = api.propagation.getBaggage(api.context.active());
-        span.setAttribute("componentName", currentBaggage?.componentName);
-        return ctxOrFn(span);
-      };
-      return this._tracer.startActiveSpan(name, optionsOrFn, api.context.active(), wrappedFn2);
-    }
-    const wrappedFn = span => {
-      const currentBaggage = api.propagation.getBaggage(ctxOrFn ?? api.context.active());
-      span.setAttribute("componentName", currentBaggage?.componentName);
-      return fn(span);
-    };
-    return this._tracer.startActiveSpan(name, optionsOrFn, ctxOrFn, wrappedFn);
-  }
-};
-
-// src/mastra/index.ts
-var _Mastra_decorators, _init;
-_Mastra_decorators = [InstrumentClass({
-  prefix: "mastra",
-  excludeMethods: ["getLogger", "getTelemetry"]
-})];
-exports.Mastra = class Mastra {
-  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
-        });
-        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 = 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;
-  }
-  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 = __decoratorStart();
-  exports.Mastra = __decorateElement(_init, 0, "Mastra", _Mastra_decorators, exports.Mastra);
-  __runInitializers(_init, 1, exports.Mastra);
-  return exports.Mastra;
-})();