@mastra/core 0.0.0-commonjs-20250227130920

package/dist/mastra/index.cjs

@@ -0,0 +1,1741 @@
+'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');
+
+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, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", {
+  value,
+  configurable: true
+});
+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
+    }, 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;
+  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 (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`
+    });
+    this.client = client.createClient({
+      url: this.rewriteDbUrl(config.url),
+      authToken: config.authToken
+    });
+  }
+  rewriteDbUrl(url) {
+    if (url.startsWith("file:") && !url.startsWith("file:/")) {
+      const cwd = process.cwd();
+      const relativePath = url.slice("file:".length);
+      if (cwd.endsWith(".mastra") || cwd.endsWith(".mastra/")) {
+        const baseDir = path.join(cwd, `..`);
+        const fullPath = path.join(baseDir, relativePath);
+        this.logger.debug(`Initializing LibSQL db with url ${url} with relative file path from inside .mastra directory. Rewriting relative file url to "file:${fullPath}". This ensures it's outside the .mastra directory. If the db is stored inside .mastra it will be deleted when Mastra re-bundles code.`);
+        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;
+      }
+      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" ? JSON.parse(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
+        });
+        agents[key] = agent;
+      });
+    }
+    this.agents = agents;
+    this.workflows = {};
+    if (config?.workflows) {
+      Object.entries(config.workflows).forEach(([key, workflow]) => {
+        workflow.__registerPrimitives({
+          logger: this.getLogger(),
+          telemetry: this.telemetry,
+          storage: this.storage,
+          memory: this.memory,
+          agents: this.agents,
+          tts: this.tts,
+          vectors: this.vectors
+        });
+        this.workflows[key] = workflow;
+      });
+    }
+    this.setLogger({
+      logger
+    });
+  }
+  getAgent(name) {
+    const agent = this.agents?.[name];
+    if (!agent) {
+      throw new Error(`Agent with name ${String(name)} not found`);
+    }
+    return this.agents[name];
+  }
+  getAgents() {
+    return this.agents;
+  }
+  getVector(name) {
+    const vector = this.vectors?.[name];
+    if (!vector) {
+      throw new Error(`Vector with name ${String(name)} not found`);
+    }
+    return vector;
+  }
+  getVectors() {
+    return this.vectors;
+  }
+  getDeployer() {
+    return this.deployer;
+  }
+  getWorkflow(id, {
+    serialized
+  } = {}) {
+    const workflow = this.workflows?.[id];
+    if (!workflow) {
+      throw new Error(`Workflow with ID ${String(id)} not found`);
+    }
+    if (serialized) {
+      return {
+        name: workflow.name
+      };
+    }
+    return workflow;
+  }
+  getWorkflows(props = {}) {
+    if (props.serialized) {
+      return Object.entries(this.workflows).reduce((acc, [k, v]) => {
+        return {
+          ...acc,
+          [k]: {
+            name: v.name
+          }
+        };
+      }, {});
+    }
+    return this.workflows;
+  }
+  setStorage(storage) {
+    this.storage = storage;
+  }
+  setLogger({
+    logger
+  }) {
+    this.logger = logger;
+    if (this.agents) {
+      Object.keys(this.agents).forEach(key => {
+        this.agents?.[key]?.__setLogger(this.logger);
+      });
+    }
+    if (this.workflows) {
+      Object.keys(this.workflows).forEach(key => {
+        this.workflows?.[key]?.__setLogger(this.logger);
+      });
+    }
+    if (this.memory) {
+      this.memory.__setLogger(this.logger);
+    }
+    if (this.deployer) {
+      this.deployer.__setLogger(this.logger);
+    }
+    if (this.tts) {
+      Object.keys(this.tts).forEach(key => {
+        this.tts?.[key]?.__setLogger(this.logger);
+      });
+    }
+    if (this.storage) {
+      this.storage.__setLogger(this.logger);
+    }
+    if (this.vectors) {
+      Object.keys(this.vectors).forEach(key => {
+        this.vectors?.[key]?.__setLogger(this.logger);
+      });
+    }
+  }
+  setTelemetry(telemetry) {
+    this.telemetry = Telemetry.init(telemetry);
+    if (this.agents) {
+      Object.keys(this.agents).forEach(key => {
+        if (this.telemetry) {
+          this.agents?.[key]?.__setTelemetry(this.telemetry);
+        }
+      });
+    }
+    if (this.workflows) {
+      Object.keys(this.workflows).forEach(key => {
+        if (this.telemetry) {
+          this.workflows?.[key]?.__setTelemetry(this.telemetry);
+        }
+      });
+    }
+    if (this.memory) {
+      this.memory = this.telemetry.traceClass(this.memory, {
+        excludeMethods: ["__setTelemetry", "__getTelemetry"]
+      });
+      this.memory.__setTelemetry(this.telemetry);
+    }
+    if (this.deployer) {
+      this.deployer = this.telemetry.traceClass(this.deployer, {
+        excludeMethods: ["__setTelemetry", "__getTelemetry"]
+      });
+      this.deployer.__setTelemetry(this.telemetry);
+    }
+    if (this.tts) {
+      let tts = {};
+      Object.entries(this.tts).forEach(([key, ttsCl]) => {
+        if (this.telemetry) {
+          tts[key] = this.telemetry.traceClass(ttsCl, {
+            excludeMethods: ["__setTelemetry", "__getTelemetry"]
+          });
+          tts[key].__setTelemetry(this.telemetry);
+        }
+      });
+      this.tts = tts;
+    }
+    if (this.storage) {
+      this.storage = this.telemetry.traceClass(this.storage, {
+        excludeMethods: ["__setTelemetry", "__getTelemetry"]
+      });
+      this.storage.__setTelemetry(this.telemetry);
+    }
+    if (this.vectors) {
+      let vectors = {};
+      Object.entries(this.vectors).forEach(([key, vector]) => {
+        if (this.telemetry) {
+          vectors[key] = this.telemetry.traceClass(vector, {
+            excludeMethods: ["__setTelemetry", "__getTelemetry"]
+          });
+          vectors[key].__setTelemetry(this.telemetry);
+        }
+      });
+      this.vectors = vectors;
+    }
+  }
+  getLogger() {
+    return this.logger;
+  }
+  getTelemetry() {
+    return this.telemetry;
+  }
+  async getLogsByRunId({
+    runId,
+    transportId
+  }) {
+    if (!transportId) {
+      throw new Error("Transport ID is required");
+    }
+    return await this.logger.getLogsByRunId({
+      runId,
+      transportId
+    });
+  }
+  async getLogs(transportId) {
+    if (!transportId) {
+      throw new Error("Transport ID is required");
+    }
+    return await this.logger.getLogs(transportId);
+  }
+};
+exports.Mastra = /*@__PURE__*/(_ => {
+  _init = __decoratorStart();
+  exports.Mastra = __decorateElement(_init, 0, "Mastra", _Mastra_decorators, exports.Mastra);
+  __runInitializers(_init, 1, exports.Mastra);
+  return exports.Mastra;
+})();