@mastra/core 0.5.0-alpha.8 → 0.5.0

package/dist/memory/index.cjs

@@ -1,2056 +1,10 @@
 'use strict';
 
-var fs = require('fs');
-var path = require('path');
-var stream = require('stream');
-var pino = require('pino');
-var pretty = require('pino-pretty');
-var client = require('@libsql/client');
-var ai = require('ai');
-var node_modulesPath = require('node_modules-path');
+var chunkKFQ7Z3PO_cjs = require('../chunk-KFQ7Z3PO.cjs');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var path__default = /*#__PURE__*/_interopDefault(path);
-var pino__default = /*#__PURE__*/_interopDefault(pino);
-var pretty__default = /*#__PURE__*/_interopDefault(pretty);
-var node_modulesPath__default = /*#__PURE__*/_interopDefault(node_modulesPath);
 
-// src/memory/memory.ts
-var RegisteredLogger = {
-  LLM: "LLM"};
-var LogLevel = {
-  INFO: "info"};
-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);
-}
-
-// 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 deepMerge(target, source) {
-  const output = { ...target };
-  if (!source) return output;
-  Object.keys(source).forEach((key) => {
-    const targetValue = output[key];
-    const sourceValue = source[key];
-    if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
-      output[key] = sourceValue;
-    } else if (sourceValue instanceof Object && targetValue instanceof Object && !Array.isArray(sourceValue) && !Array.isArray(targetValue)) {
-      output[key] = deepMerge(targetValue, sourceValue);
-    } else if (sourceValue !== void 0) {
-      output[key] = sourceValue;
-    }
-  });
-  return output;
-}
-var cachedPath = false;
-function getModelCachePath() {
-  if (cachedPath) return cachedPath;
-  const firstNodeModules = node_modulesPath__default.default().split("node_modules")[0];
-  cachedPath = path__default.default.join(firstNodeModules, "node_modules", ".fastembed-model-cache");
-  return cachedPath;
-}
-function unbundleableImport(name) {
-  const nonStaticallyAnalyzableName = `${name}?d=${Date.now()}`;
-  return import(nonStaticallyAnalyzableName.split(`?`)[0]);
-}
-async function generateEmbeddings(values, modelType) {
-  try {
-    let mod;
-    const importErrors = [];
-    {
-      try {
-        mod = await unbundleableImport("fastembed");
-      } catch (e) {
-        if (e instanceof Error) {
-          importErrors.push(e);
-        } else {
-          throw e;
-        }
-      }
-    }
-    if (!mod) {
-      throw new Error(`${importErrors.map((e) => e.message).join(`
-`)}
-
-This runtime does not support fastembed-js, which is the default embedder in Mastra. 
-Scroll up to read import errors. These errors mean you can't use the default Mastra embedder on this hosting platform.
-You can either use Mastra Cloud which supports the default embedder, or you can configure an alternate provider.
-
-For example if you're using Memory:
-
-import { openai } from "@ai-sdk/openai";
-
-const memory = new Memory({
-  embedder: openai.embedding("text-embedding-3-small"), // <- doesn't have to be openai
-})
-
-Visit https://sdk.vercel.ai/docs/foundations/overview#embedding-models to find an alternate embedding provider
-
-If you do not want to use the Memory semantic recall feature, you can disable it entirely and this error will go away.
-
-const memory = new Memory({
-  options: {
-    semanticRecall: false // <- an embedder will not be required with this set to false
-  }
-})
-`);
-    }
-    const { FlagEmbedding, EmbeddingModel } = mod;
-    const model = await FlagEmbedding.init({
-      model: EmbeddingModel[modelType],
-      cacheDir: getModelCachePath()
-    });
-    const embeddings = await model.embed(values);
-    const allResults = [];
-    for await (const result of embeddings) {
-      allResults.push(...result.map((embedding) => Array.from(embedding)));
-    }
-    if (allResults.length === 0) throw new Error("No embeddings generated");
-    return {
-      embeddings: allResults
-    };
-  } catch (error) {
-    console.error("Error generating embeddings:", error);
-    throw error;
-  }
-}
-var fastEmbedProvider = ai.experimental_customProvider({
-  textEmbeddingModels: {
-    "bge-small-en-v1.5": {
-      specificationVersion: "v1",
-      provider: "fastembed",
-      modelId: "bge-small-en-v1.5",
-      maxEmbeddingsPerCall: 256,
-      supportsParallelCalls: true,
-      async doEmbed({ values }) {
-        return generateEmbeddings(values, "BGESmallENV15");
-      }
-    },
-    "bge-base-en-v1.5": {
-      specificationVersion: "v1",
-      provider: "fastembed",
-      modelId: "bge-base-en-v1.5",
-      maxEmbeddingsPerCall: 256,
-      supportsParallelCalls: true,
-      async doEmbed({ values }) {
-        return generateEmbeddings(values, "BGEBaseENV15");
-      }
-    }
-  }
+Object.defineProperty(exports, "MastraMemory", {
+  enumerable: true,
+  get: function () { return chunkKFQ7Z3PO_cjs.MastraMemory; }
 });
-var defaultEmbedder = fastEmbedProvider.textEmbeddingModel;
-
-// src/vector/vector.ts
-var MastraVector = class extends MastraBase {
-  constructor() {
-    super({ name: "MastraVector", component: "VECTOR" });
-  }
-  baseKeys = {
-    query: ["queryVector", "topK", "filter", "includeVector"],
-    upsert: ["vectors", "metadata", "ids"],
-    createIndex: ["dimension", "metric"]
-  };
-  normalizeArgs(method, [first, ...rest], extendedKeys = []) {
-    if (typeof first === "object") {
-      return first;
-    }
-    this.logger.warn(
-      `Deprecation Warning: Passing individual arguments to ${method}() is deprecated. Please use an object parameter instead.`
-    );
-    const baseKeys = this.baseKeys[method] || [];
-    const paramKeys = [...baseKeys, ...extendedKeys].slice(0, rest.length);
-    return {
-      indexName: first,
-      ...Object.fromEntries(paramKeys.map((key, i) => [key, rest[i]]))
-    };
-  }
-  async updateIndexById(_indexName, _id, _update) {
-    throw new Error("updateIndexById is not implemented yet");
-  }
-  async deleteIndexById(_indexName, _id) {
-    throw new Error("deleteById is not implemented yet");
-  }
-};
-
-// src/vector/filter/base.ts
-var BaseFilterTranslator = class _BaseFilterTranslator {
-  /**
-   * Operator type checks
-   */
-  isOperator(key) {
-    return key.startsWith("$");
-  }
-  static BASIC_OPERATORS = ["$eq", "$ne"];
-  static NUMERIC_OPERATORS = ["$gt", "$gte", "$lt", "$lte"];
-  static ARRAY_OPERATORS = ["$in", "$nin", "$all", "$elemMatch"];
-  static LOGICAL_OPERATORS = ["$and", "$or", "$not", "$nor"];
-  static ELEMENT_OPERATORS = ["$exists"];
-  static REGEX_OPERATORS = ["$regex", "$options"];
-  static DEFAULT_OPERATORS = {
-    logical: _BaseFilterTranslator.LOGICAL_OPERATORS,
-    basic: _BaseFilterTranslator.BASIC_OPERATORS,
-    numeric: _BaseFilterTranslator.NUMERIC_OPERATORS,
-    array: _BaseFilterTranslator.ARRAY_OPERATORS,
-    element: _BaseFilterTranslator.ELEMENT_OPERATORS,
-    regex: _BaseFilterTranslator.REGEX_OPERATORS
-  };
-  isLogicalOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.logical.includes(key);
-  }
-  isBasicOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.basic.includes(key);
-  }
-  isNumericOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.numeric.includes(key);
-  }
-  isArrayOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.array.includes(key);
-  }
-  isElementOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.element.includes(key);
-  }
-  isRegexOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.regex.includes(key);
-  }
-  isFieldOperator(key) {
-    return this.isOperator(key) && !this.isLogicalOperator(key);
-  }
-  isCustomOperator(key) {
-    const support = this.getSupportedOperators();
-    return support.custom?.includes(key) ?? false;
-  }
-  getSupportedOperators() {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS;
-  }
-  isValidOperator(key) {
-    const support = this.getSupportedOperators();
-    const allSupported = Object.values(support).flat();
-    return allSupported.includes(key);
-  }
-  /**
-   * Value normalization for comparison operators
-   */
-  normalizeComparisonValue(value) {
-    if (value instanceof Date) {
-      return value.toISOString();
-    }
-    if (typeof value === "number" && Object.is(value, -0)) {
-      return 0;
-    }
-    return value;
-  }
-  /**
-   * Helper method to simulate $all operator using $and + $eq when needed.
-   * Some vector stores don't support $all natively.
-   */
-  simulateAllOperator(field, values) {
-    return {
-      $and: values.map((value) => ({
-        [field]: { $in: [this.normalizeComparisonValue(value)] }
-      }))
-    };
-  }
-  /**
-   * Utility functions for type checking
-   */
-  isPrimitive(value) {
-    return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-  }
-  isRegex(value) {
-    return value instanceof RegExp;
-  }
-  isEmpty(obj) {
-    return obj === null || obj === void 0 || typeof obj === "object" && Object.keys(obj).length === 0;
-  }
-  static ErrorMessages = {
-    UNSUPPORTED_OPERATOR: (op) => `Unsupported operator: ${op}`,
-    INVALID_LOGICAL_OPERATOR_LOCATION: (op, path2) => `Logical operator ${op} cannot be used at field level: ${path2}`,
-    NOT_REQUIRES_OBJECT: `$not operator requires an object`,
-    NOT_CANNOT_BE_EMPTY: `$not operator cannot be empty`,
-    INVALID_LOGICAL_OPERATOR_CONTENT: (path2) => `Logical operators must contain field conditions, not direct operators: ${path2}`,
-    INVALID_TOP_LEVEL_OPERATOR: (op) => `Invalid top-level operator: ${op}`,
-    ELEM_MATCH_REQUIRES_OBJECT: `$elemMatch requires an object with conditions`
-  };
-  /**
-   * Helper to handle array value normalization consistently
-   */
-  normalizeArrayValues(values) {
-    return values.map((value) => this.normalizeComparisonValue(value));
-  }
-  validateFilter(filter) {
-    const validation = this.validateFilterSupport(filter);
-    if (!validation.supported) {
-      throw new Error(validation.messages.join(", "));
-    }
-  }
-  /**
-   * Validates if a filter structure is supported by the specific vector DB
-   * and returns detailed validation information.
-   */
-  validateFilterSupport(node, path2 = "") {
-    const messages = [];
-    if (this.isPrimitive(node) || this.isEmpty(node)) {
-      return { supported: true, messages: [] };
-    }
-    if (Array.isArray(node)) {
-      const arrayResults = node.map((item) => this.validateFilterSupport(item, path2));
-      const arrayMessages = arrayResults.flatMap((r) => r.messages);
-      return {
-        supported: arrayResults.every((r) => r.supported),
-        messages: arrayMessages
-      };
-    }
-    const nodeObj = node;
-    let isSupported = true;
-    for (const [key, value] of Object.entries(nodeObj)) {
-      const newPath = path2 ? `${path2}.${key}` : key;
-      if (this.isOperator(key)) {
-        if (!this.isValidOperator(key)) {
-          isSupported = false;
-          messages.push(_BaseFilterTranslator.ErrorMessages.UNSUPPORTED_OPERATOR(key));
-          continue;
-        }
-        if (!path2 && !this.isLogicalOperator(key)) {
-          isSupported = false;
-          messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_TOP_LEVEL_OPERATOR(key));
-          continue;
-        }
-        if (key === "$elemMatch" && (typeof value !== "object" || Array.isArray(value))) {
-          isSupported = false;
-          messages.push(_BaseFilterTranslator.ErrorMessages.ELEM_MATCH_REQUIRES_OBJECT);
-          continue;
-        }
-        if (this.isLogicalOperator(key)) {
-          if (key === "$not") {
-            if (Array.isArray(value) || typeof value !== "object") {
-              isSupported = false;
-              messages.push(_BaseFilterTranslator.ErrorMessages.NOT_REQUIRES_OBJECT);
-              continue;
-            }
-            if (this.isEmpty(value)) {
-              isSupported = false;
-              messages.push(_BaseFilterTranslator.ErrorMessages.NOT_CANNOT_BE_EMPTY);
-              continue;
-            }
-            continue;
-          }
-          if (path2 && !this.isLogicalOperator(path2.split(".").pop())) {
-            isSupported = false;
-            messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_LOGICAL_OPERATOR_LOCATION(key, newPath));
-            continue;
-          }
-          if (Array.isArray(value)) {
-            const hasDirectOperators = value.some(
-              (item) => typeof item === "object" && Object.keys(item).length === 1 && this.isFieldOperator(Object.keys(item)[0])
-            );
-            if (hasDirectOperators) {
-              isSupported = false;
-              messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_LOGICAL_OPERATOR_CONTENT(newPath));
-              continue;
-            }
-          }
-        }
-      }
-      const nestedValidation = this.validateFilterSupport(value, newPath);
-      if (!nestedValidation.supported) {
-        isSupported = false;
-        messages.push(...nestedValidation.messages);
-      }
-    }
-    return { supported: isSupported, messages };
-  }
-};
-
-// src/vector/libsql/filter.ts
-var LibSQLFilterTranslator = class extends BaseFilterTranslator {
-  getSupportedOperators() {
-    return {
-      ...BaseFilterTranslator.DEFAULT_OPERATORS,
-      regex: [],
-      custom: ["$contains", "$size"]
-    };
-  }
-  translate(filter) {
-    if (this.isEmpty(filter)) {
-      return filter;
-    }
-    this.validateFilter(filter);
-    return this.translateNode(filter);
-  }
-  translateNode(node, currentPath = "") {
-    if (this.isRegex(node)) {
-      throw new Error("Direct regex pattern format is not supported in LibSQL");
-    }
-    const withPath = (result2) => currentPath ? { [currentPath]: result2 } : result2;
-    if (this.isPrimitive(node)) {
-      return withPath({ $eq: this.normalizeComparisonValue(node) });
-    }
-    if (Array.isArray(node)) {
-      return withPath({ $in: this.normalizeArrayValues(node) });
-    }
-    const entries = Object.entries(node);
-    const result = {};
-    for (const [key, value] of entries) {
-      const newPath = currentPath ? `${currentPath}.${key}` : key;
-      if (this.isLogicalOperator(key)) {
-        result[key] = Array.isArray(value) ? value.map((filter) => this.translateNode(filter)) : this.translateNode(value);
-      } else if (this.isOperator(key)) {
-        if (this.isArrayOperator(key) && !Array.isArray(value) && key !== "$elemMatch") {
-          result[key] = [value];
-        } else if (this.isBasicOperator(key) && Array.isArray(value)) {
-          result[key] = JSON.stringify(value);
-        } else {
-          result[key] = value;
-        }
-      } else if (typeof value === "object" && value !== null) {
-        const hasOperators = Object.keys(value).some((k) => this.isOperator(k));
-        if (hasOperators) {
-          result[newPath] = this.translateNode(value);
-        } else {
-          Object.assign(result, this.translateNode(value, newPath));
-        }
-      } else {
-        result[newPath] = this.translateNode(value);
-      }
-    }
-    return result;
-  }
-  // TODO: Look more into regex support for LibSQL
-  // private translateRegexPattern(pattern: string, options: string = ''): any {
-  //   if (!options) return { $regex: pattern };
-  //   const flags = options
-  //     .split('')
-  //     .filter(f => 'imsux'.includes(f))
-  //     .join('');
-  //   return {
-  //     $regex: pattern,
-  //     $options: flags,
-  //   };
-  // }
-};
-
-// src/vector/libsql/sql-builder.ts
-var createBasicOperator = (symbol) => {
-  return (key) => ({
-    sql: `CASE 
-      WHEN ? IS NULL THEN json_extract(metadata, '$."${handleKey(key)}"') IS ${symbol === "=" ? "" : "NOT"} NULL
-      ELSE json_extract(metadata, '$."${handleKey(key)}"') ${symbol} ?
-    END`,
-    needsValue: true,
-    transformValue: (value) => {
-      return [value, value];
-    }
-  });
-};
-var createNumericOperator = (symbol) => {
-  return (key) => ({
-    sql: `CAST(json_extract(metadata, '$."${handleKey(key)}"') AS NUMERIC) ${symbol} ?`,
-    needsValue: true
-  });
-};
-var validateJsonArray = (key) => `json_valid(json_extract(metadata, '$."${handleKey(key)}"'))
-   AND json_type(json_extract(metadata, '$."${handleKey(key)}"')) = 'array'`;
-var FILTER_OPERATORS = {
-  $eq: createBasicOperator("="),
-  $ne: createBasicOperator("!="),
-  $gt: createNumericOperator(">"),
-  $gte: createNumericOperator(">="),
-  $lt: createNumericOperator("<"),
-  $lte: createNumericOperator("<="),
-  // Array Operators
-  $in: (key, value) => ({
-    sql: `json_extract(metadata, '$."${handleKey(key)}"') IN (${value.map(() => "?").join(",")})`,
-    needsValue: true
-  }),
-  $nin: (key, value) => ({
-    sql: `json_extract(metadata, '$."${handleKey(key)}"') NOT IN (${value.map(() => "?").join(",")})`,
-    needsValue: true
-  }),
-  $all: (key) => ({
-    sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
-    needsValue: true,
-    transformValue: (value) => {
-      const arrayValue = Array.isArray(value) ? value : [value];
-      if (arrayValue.length === 0) {
-        return {
-          sql: "1 = 0",
-          values: []
-        };
-      }
-      return {
-        sql: `(
-          CASE
-            WHEN ${validateJsonArray(key)} THEN
-                NOT EXISTS (
-                    SELECT value 
-                    FROM json_each(?) 
-                    WHERE value NOT IN (
-                    SELECT value 
-                    FROM json_each(json_extract(metadata, '$."${handleKey(key)}"'))
-                )
-            )
-            ELSE FALSE
-          END
-        )`,
-        values: [JSON.stringify(arrayValue)]
-      };
-    }
-  }),
-  $elemMatch: (key) => ({
-    sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
-    needsValue: true,
-    transformValue: (value) => {
-      if (typeof value !== "object" || Array.isArray(value)) {
-        throw new Error("$elemMatch requires an object with conditions");
-      }
-      const conditions = Object.entries(value).map(([field, fieldValue]) => {
-        if (field.startsWith("$")) {
-          const { sql, values } = buildCondition("elem.value", { [field]: fieldValue });
-          const pattern = /json_extract\(metadata, '\$\."[^"]*"(\."[^"]*")*'\)/g;
-          const elemSql = sql.replace(pattern, "elem.value");
-          return { sql: elemSql, values };
-        } else if (typeof fieldValue === "object" && !Array.isArray(fieldValue)) {
-          const { sql, values } = buildCondition(field, fieldValue);
-          const pattern = /json_extract\(metadata, '\$\."[^"]*"(\."[^"]*")*'\)/g;
-          const elemSql = sql.replace(pattern, `json_extract(elem.value, '$."${field}"')`);
-          return { sql: elemSql, values };
-        } else {
-          return {
-            sql: `json_extract(elem.value, '$."${field}"') = ?`,
-            values: [fieldValue]
-          };
-        }
-      });
-      return {
-        sql: `(
-          CASE
-            WHEN ${validateJsonArray(key)} THEN
-              EXISTS (
-                SELECT 1 
-                FROM json_each(json_extract(metadata, '$."${handleKey(key)}"')) as elem
-                WHERE ${conditions.map((c) => c.sql).join(" AND ")}
-              )
-            ELSE FALSE
-          END
-        )`,
-        values: conditions.flatMap((c) => c.values)
-      };
-    }
-  }),
-  // Element Operators
-  $exists: (key) => ({
-    sql: `json_extract(metadata, '$."${handleKey(key)}"') IS NOT NULL`,
-    needsValue: false
-  }),
-  // Logical Operators
-  $and: (key) => ({
-    sql: `(${key})`,
-    needsValue: false
-  }),
-  $or: (key) => ({
-    sql: `(${key})`,
-    needsValue: false
-  }),
-  $not: (key) => ({ sql: `NOT (${key})`, needsValue: false }),
-  $nor: (key) => ({
-    sql: `NOT (${key})`,
-    needsValue: false
-  }),
-  $size: (key, paramIndex) => ({
-    sql: `(
-    CASE
-      WHEN json_type(json_extract(metadata, '$."${handleKey(key)}"')) = 'array' THEN 
-        json_array_length(json_extract(metadata, '$."${handleKey(key)}"')) = $${paramIndex}
-      ELSE FALSE
-    END
-  )`,
-    needsValue: true
-  }),
-  //   /**
-  //    * Regex Operators
-  //    * Supports case insensitive and multiline
-  //    */
-  //   $regex: (key: string): FilterOperator => ({
-  //     sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
-  //     needsValue: true,
-  //     transformValue: (value: any) => {
-  //       const pattern = typeof value === 'object' ? value.$regex : value;
-  //       const options = typeof value === 'object' ? value.$options || '' : '';
-  //       let sql = `json_extract(metadata, '$."${handleKey(key)}"')`;
-  //       // Handle multiline
-  //       //   if (options.includes('m')) {
-  //       //     sql = `REPLACE(${sql}, CHAR(10), '\n')`;
-  //       //   }
-  //       //       let finalPattern = pattern;
-  //       // if (options) {
-  //       //   finalPattern = `(\\?${options})${pattern}`;
-  //       // }
-  //       //   // Handle case insensitivity
-  //       //   if (options.includes('i')) {
-  //       //     sql = `LOWER(${sql}) REGEXP LOWER(?)`;
-  //       //   } else {
-  //       //     sql = `${sql} REGEXP ?`;
-  //       //   }
-  //       if (options.includes('m')) {
-  //         sql = `EXISTS (
-  //         SELECT 1
-  //         FROM json_each(
-  //           json_array(
-  //             ${sql},
-  //             REPLACE(${sql}, CHAR(10), CHAR(13))
-  //           )
-  //         ) as lines
-  //         WHERE lines.value REGEXP ?
-  //       )`;
-  //       } else {
-  //         sql = `${sql} REGEXP ?`;
-  //       }
-  //       // Handle case insensitivity
-  //       if (options.includes('i')) {
-  //         sql = sql.replace('REGEXP ?', 'REGEXP LOWER(?)');
-  //         sql = sql.replace('value REGEXP', 'LOWER(value) REGEXP');
-  //       }
-  //       // Handle extended - allows whitespace and comments in pattern
-  //       if (options.includes('x')) {
-  //         // Remove whitespace and comments from pattern
-  //         const cleanPattern = pattern.replace(/\s+|#.*$/gm, '');
-  //         return {
-  //           sql,
-  //           values: [cleanPattern],
-  //         };
-  //       }
-  //       return {
-  //         sql,
-  //         values: [pattern],
-  //       };
-  //     },
-  //   }),
-  $contains: (key) => ({
-    sql: `json_extract(metadata, '$."${handleKey(key)}"') = ?`,
-    needsValue: true,
-    transformValue: (value) => {
-      if (Array.isArray(value)) {
-        return {
-          sql: `(
-            SELECT ${validateJsonArray(key)}
-            AND EXISTS (
-              SELECT 1 
-              FROM json_each(json_extract(metadata, '$."${handleKey(key)}"')) as m
-              WHERE m.value IN (SELECT value FROM json_each(?))
-            )
-          )`,
-          values: [JSON.stringify(value)]
-        };
-      }
-      if (value && typeof value === "object") {
-        let traverse2 = function(obj, path2 = []) {
-          for (const [k, v] of Object.entries(obj)) {
-            const currentPath = [...path2, k];
-            if (v && typeof v === "object" && !Array.isArray(v)) {
-              traverse2(v, currentPath);
-            } else {
-              paths.push(currentPath.join("."));
-              values.push(v);
-            }
-          }
-        };
-        const paths = [];
-        const values = [];
-        traverse2(value);
-        return {
-          sql: `(${paths.map((path2) => `json_extract(metadata, '$."${handleKey(key)}"."${path2}"') = ?`).join(" AND ")})`,
-          values
-        };
-      }
-      return value;
-    }
-  })
-};
-var handleKey = (key) => {
-  return key.replace(/\./g, '"."');
-};
-function buildFilterQuery(filter) {
-  if (!filter) {
-    return { sql: "", values: [] };
-  }
-  const values = [];
-  const conditions = Object.entries(filter).map(([key, value]) => {
-    const condition = buildCondition(key, value);
-    values.push(...condition.values);
-    return condition.sql;
-  }).join(" AND ");
-  return {
-    sql: conditions ? `WHERE ${conditions}` : "",
-    values
-  };
-}
-function buildCondition(key, value, parentPath) {
-  if (["$and", "$or", "$not", "$nor"].includes(key)) {
-    return handleLogicalOperator(key, value);
-  }
-  if (!value || typeof value !== "object") {
-    return {
-      sql: `json_extract(metadata, '$."${key.replace(/\./g, '"."')}"') = ?`,
-      values: [value]
-    };
-  }
-  return handleOperator(key, value);
-}
-function handleLogicalOperator(key, value, parentPath) {
-  if (!value || value.length === 0) {
-    switch (key) {
-      case "$and":
-      case "$nor":
-        return { sql: "true", values: [] };
-      case "$or":
-        return { sql: "false", values: [] };
-      case "$not":
-        throw new Error("$not operator cannot be empty");
-      default:
-        return { sql: "true", values: [] };
-    }
-  }
-  if (key === "$not") {
-    const entries = Object.entries(value);
-    const conditions2 = entries.map(([fieldKey, fieldValue]) => buildCondition(fieldKey, fieldValue));
-    return {
-      sql: `NOT (${conditions2.map((c) => c.sql).join(" AND ")})`,
-      values: conditions2.flatMap((c) => c.values)
-    };
-  }
-  const values = [];
-  const joinOperator = key === "$or" || key === "$nor" ? "OR" : "AND";
-  const conditions = Array.isArray(value) ? value.map((f) => {
-    const entries = Object.entries(f);
-    return entries.map(([k, v]) => buildCondition(k, v));
-  }) : [buildCondition(key, value)];
-  const joined = conditions.flat().map((c) => {
-    values.push(...c.values);
-    return c.sql;
-  }).join(` ${joinOperator} `);
-  return {
-    sql: key === "$nor" ? `NOT (${joined})` : `(${joined})`,
-    values
-  };
-}
-function handleOperator(key, value) {
-  if (typeof value === "object" && !Array.isArray(value)) {
-    const entries = Object.entries(value);
-    const results = entries.map(
-      ([operator2, operatorValue2]) => operator2 === "$not" ? {
-        sql: `NOT (${Object.entries(operatorValue2).map(([op, val]) => processOperator(key, op, val).sql).join(" AND ")})`,
-        values: Object.entries(operatorValue2).flatMap(
-          ([op, val]) => processOperator(key, op, val).values
-        )
-      } : processOperator(key, operator2, operatorValue2)
-    );
-    return {
-      sql: `(${results.map((r) => r.sql).join(" AND ")})`,
-      values: results.flatMap((r) => r.values)
-    };
-  }
-  const [[operator, operatorValue] = []] = Object.entries(value);
-  return processOperator(key, operator, operatorValue);
-}
-var processOperator = (key, operator, operatorValue) => {
-  if (!operator.startsWith("$") || !FILTER_OPERATORS[operator]) {
-    throw new Error(`Invalid operator: ${operator}`);
-  }
-  const operatorFn = FILTER_OPERATORS[operator];
-  const operatorResult = operatorFn(key, operatorValue);
-  if (!operatorResult.needsValue) {
-    return { sql: operatorResult.sql, values: [] };
-  }
-  const transformed = operatorResult.transformValue ? operatorResult.transformValue(operatorValue) : operatorValue;
-  if (transformed && typeof transformed === "object" && "sql" in transformed) {
-    return transformed;
-  }
-  return {
-    sql: operatorResult.sql,
-    values: Array.isArray(transformed) ? transformed : [transformed]
-  };
-};
-
-// src/vector/libsql/index.ts
-var LibSQLVector = class extends MastraVector {
-  turso;
-  constructor({
-    connectionUrl,
-    authToken,
-    syncUrl,
-    syncInterval
-  }) {
-    super();
-    this.turso = client.createClient({
-      url: this.rewriteDbUrl(connectionUrl),
-      syncUrl,
-      authToken,
-      syncInterval
-    });
-  }
-  // 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;
-  }
-  transformFilter(filter) {
-    const translator = new LibSQLFilterTranslator();
-    return translator.translate(filter);
-  }
-  async query(...args) {
-    const params = this.normalizeArgs("query", args, ["minScore"]);
-    try {
-      const { indexName, queryVector, topK = 10, filter, includeVector = false, minScore = 0 } = params;
-      const vectorStr = `[${queryVector.join(",")}]`;
-      const translatedFilter = this.transformFilter(filter);
-      const { sql: filterQuery, values: filterValues } = buildFilterQuery(translatedFilter);
-      filterValues.push(minScore);
-      const query = `
-        WITH vector_scores AS (
-          SELECT
-            vector_id as id,
-            (1-vector_distance_cos(embedding, '${vectorStr}')) as score,
-            metadata
-            ${includeVector ? ", vector_extract(embedding) as embedding" : ""}
-          FROM ${indexName}
-          ${filterQuery}
-        )
-        SELECT *
-        FROM vector_scores
-        WHERE score > ?
-        ORDER BY score DESC
-        LIMIT ${topK}`;
-      const result = await this.turso.execute({
-        sql: query,
-        args: filterValues
-      });
-      return result.rows.map(({ id, score, metadata, embedding }) => ({
-        id,
-        score,
-        metadata: JSON.parse(metadata ?? "{}"),
-        ...includeVector && embedding && { vector: JSON.parse(embedding) }
-      }));
-    } finally {
-    }
-  }
-  async upsert(...args) {
-    const params = this.normalizeArgs("upsert", args);
-    const { indexName, vectors, metadata, ids } = params;
-    const tx = await this.turso.transaction("write");
-    try {
-      const vectorIds = ids || vectors.map(() => crypto.randomUUID());
-      for (let i = 0; i < vectors.length; i++) {
-        const query = `
-          INSERT INTO ${indexName} (vector_id, embedding, metadata)
-          VALUES (?, vector32(?), ?)
-          ON CONFLICT(vector_id) DO UPDATE SET
-            embedding = vector32(?),
-            metadata = ?
-        `;
-        await tx.execute({
-          sql: query,
-          // @ts-ignore
-          args: [
-            vectorIds[i],
-            JSON.stringify(vectors[i]),
-            JSON.stringify(metadata?.[i] || {}),
-            JSON.stringify(vectors[i]),
-            JSON.stringify(metadata?.[i] || {})
-          ]
-        });
-      }
-      await tx.commit();
-      return vectorIds;
-    } catch (error) {
-      await tx.rollback();
-      throw error;
-    }
-  }
-  async createIndex(...args) {
-    const params = this.normalizeArgs("createIndex", args);
-    const { indexName, dimension } = params;
-    try {
-      if (!indexName.match(/^[a-zA-Z_][a-zA-Z0-9_]*$/)) {
-        throw new Error("Invalid index name format");
-      }
-      if (!Number.isInteger(dimension) || dimension <= 0) {
-        throw new Error("Dimension must be a positive integer");
-      }
-      await this.turso.execute({
-        sql: `
-        CREATE TABLE IF NOT EXISTS ${indexName} (
-          id SERIAL PRIMARY KEY,
-          vector_id TEXT UNIQUE NOT NULL,
-          embedding F32_BLOB(${dimension}),
-          metadata TEXT DEFAULT '{}'
-        );
-      `,
-        args: []
-      });
-      await this.turso.execute({
-        sql: `
-        CREATE INDEX IF NOT EXISTS ${indexName}_vector_idx
-        ON ${indexName} (libsql_vector_idx(embedding))
-      `,
-        args: []
-      });
-    } catch (error) {
-      console.error("Failed to create vector table:", error);
-      throw error;
-    } finally {
-    }
-  }
-  async deleteIndex(indexName) {
-    try {
-      await this.turso.execute({
-        sql: `DROP TABLE IF EXISTS ${indexName}`,
-        args: []
-      });
-    } catch (error) {
-      console.error("Failed to delete vector table:", error);
-      throw new Error(`Failed to delete vector table: ${error.message}`);
-    } finally {
-    }
-  }
-  async listIndexes() {
-    try {
-      const vectorTablesQuery = `
-        SELECT name FROM sqlite_master 
-        WHERE type='table' 
-        AND sql LIKE '%F32_BLOB%';
-      `;
-      const result = await this.turso.execute({
-        sql: vectorTablesQuery,
-        args: []
-      });
-      return result.rows.map((row) => row.name);
-    } catch (error) {
-      throw new Error(`Failed to list vector tables: ${error.message}`);
-    }
-  }
-  async describeIndex(indexName) {
-    try {
-      const tableInfoQuery = `
-        SELECT sql 
-        FROM sqlite_master 
-        WHERE type='table' 
-        AND name = ?;
-      `;
-      const tableInfo = await this.turso.execute({
-        sql: tableInfoQuery,
-        args: [indexName]
-      });
-      if (!tableInfo.rows[0]?.sql) {
-        throw new Error(`Table ${indexName} not found`);
-      }
-      const dimension = parseInt(tableInfo.rows[0].sql.match(/F32_BLOB\((\d+)\)/)?.[1] || "0");
-      const countQuery = `
-        SELECT COUNT(*) as count
-        FROM ${indexName};
-      `;
-      const countResult = await this.turso.execute({
-        sql: countQuery,
-        args: []
-      });
-      const metric = "cosine";
-      return {
-        dimension,
-        count: countResult?.rows?.[0]?.count ?? 0,
-        metric
-      };
-    } catch (e) {
-      throw new Error(`Failed to describe vector table: ${e.message}`);
-    }
-  }
-  /**
-   * Updates an index entry by its ID with the provided vector and/or metadata.
-   *
-   * @param indexName - The name of the index to update.
-   * @param id - The ID of the index entry to update.
-   * @param update - An object containing the vector and/or metadata to update.
-   * @param update.vector - An optional array of numbers representing the new vector.
-   * @param update.metadata - An optional record containing the new metadata.
-   * @returns A promise that resolves when the update is complete.
-   * @throws Will throw an error if no updates are provided or if the update operation fails.
-   */
-  async updateIndexById(indexName, id, update) {
-    try {
-      const updates = [];
-      const args = [];
-      if (update.vector) {
-        updates.push("embedding = vector32(?)");
-        args.push(JSON.stringify(update.vector));
-      }
-      if (update.metadata) {
-        updates.push("metadata = ?");
-        args.push(JSON.stringify(update.metadata));
-      }
-      if (updates.length === 0) {
-        throw new Error("No updates provided");
-      }
-      args.push(id);
-      const query = `
-        UPDATE ${indexName}
-        SET ${updates.join(", ")}
-        WHERE vector_id = ?;
-      `;
-      await this.turso.execute({
-        sql: query,
-        args
-      });
-    } catch (error) {
-      throw new Error(`Failed to update index by id: ${id} for index: ${indexName}: ${error.message}`);
-    }
-  }
-  async deleteIndexById(indexName, id) {
-    try {
-      await this.turso.execute({
-        sql: `DELETE FROM ${indexName} WHERE vector_id = ?`,
-        args: [id]
-      });
-    } catch (error) {
-      throw new Error(`Failed to delete index by id: ${id} for index: ${indexName}: ${error.message}`);
-    }
-  }
-  async truncateIndex(indexName) {
-    await this.turso.execute({
-      sql: `DELETE FROM ${indexName}`,
-      args: []
-    });
-  }
-};
-
-// src/memory/memory.ts
-var MastraMemory = class extends MastraBase {
-  MAX_CONTEXT_TOKENS;
-  storage;
-  vector;
-  embedder;
-  threadConfig = {
-    lastMessages: 40,
-    semanticRecall: true,
-    threads: {
-      generateTitle: true
-      // TODO: should we disable this by default to reduce latency?
-    }
-  };
-  constructor(config) {
-    super({ component: "MEMORY", name: config.name });
-    this.storage = config.storage || new LibSQLStore({
-      config: {
-        url: "file:memory.db"
-      }
-    });
-    if (config.vector) {
-      this.vector = config.vector;
-    } else {
-      const oldDb = "memory-vector.db";
-      const hasOldDb = fs.existsSync(path.join(process.cwd(), oldDb)) || fs.existsSync(path.join(process.cwd(), ".mastra", oldDb));
-      const newDb = "memory.db";
-      if (hasOldDb) {
-        this.logger.warn(
-          `Found deprecated Memory vector db file ${oldDb} this db is now merged with the default ${newDb} file. Delete the old one to use the new one. You will need to migrate any data if that's important to you. For now the deprecated path will be used but in a future breaking change we will only use the new db file path.`
-        );
-      }
-      this.vector = new LibSQLVector({
-        connectionUrl: hasOldDb ? `file:${oldDb}` : `file:${newDb}`
-      });
-    }
-    if (config.embedder) {
-      this.embedder = config.embedder;
-    } else {
-      this.embedder = defaultEmbedder("bge-small-en-v1.5");
-    }
-    if (config.options) {
-      this.threadConfig = this.getMergedThreadConfig(config.options);
-    }
-  }
-  setStorage(storage) {
-    this.storage = storage;
-  }
-  setVector(vector) {
-    this.vector = vector;
-  }
-  setEmbedder(embedder) {
-    this.embedder = embedder;
-  }
-  /**
-   * Get a system message to inject into the conversation.
-   * This will be called before each conversation turn.
-   * Implementations can override this to inject custom system messages.
-   */
-  async getSystemMessage(_input) {
-    return null;
-  }
-  /**
-   * Get tools that should be available to the agent.
-   * This will be called when converting tools for the agent.
-   * Implementations can override this to provide additional tools.
-   */
-  getTools(_config) {
-    return {};
-  }
-  async createEmbeddingIndex() {
-    const defaultDimensions = 1536;
-    const dimensionsByModelId = {
-      "bge-small-en-v1.5": 384,
-      "bge-base-en-v1.5": 768
-    };
-    const dimensions = dimensionsByModelId[this.embedder.modelId] || defaultDimensions;
-    const isDefault = dimensions === defaultDimensions;
-    const indexName = isDefault ? "memory_messages" : `memory_messages_${dimensions}`;
-    await this.vector.createIndex({ indexName, dimension: dimensions });
-    return { indexName };
-  }
-  getMergedThreadConfig(config) {
-    return deepMerge(this.threadConfig, config || {});
-  }
-  estimateTokens(text) {
-    return Math.ceil(text.split(" ").length * 1.3);
-  }
-  parseMessages(messages) {
-    return messages.map((msg) => ({
-      ...msg,
-      content: typeof msg.content === "string" && (msg.content.startsWith("[") || msg.content.startsWith("{")) ? JSON.parse(msg.content) : typeof msg.content === "number" ? String(msg.content) : msg.content
-    }));
-  }
-  convertToUIMessages(messages) {
-    function addToolMessageToChat({
-      toolMessage,
-      messages: messages2,
-      toolResultContents
-    }) {
-      const chatMessages2 = messages2.map((message) => {
-        if (message.toolInvocations) {
-          return {
-            ...message,
-            toolInvocations: message.toolInvocations.map((toolInvocation) => {
-              const toolResult = toolMessage.content.find((tool) => tool.toolCallId === toolInvocation.toolCallId);
-              if (toolResult) {
-                return {
-                  ...toolInvocation,
-                  state: "result",
-                  result: toolResult.result
-                };
-              }
-              return toolInvocation;
-            })
-          };
-        }
-        return message;
-      });
-      const resultContents = [...toolResultContents, ...toolMessage.content];
-      return { chatMessages: chatMessages2, toolResultContents: resultContents };
-    }
-    const { chatMessages } = messages.reduce(
-      (obj, message) => {
-        if (message.role === "tool") {
-          return addToolMessageToChat({
-            toolMessage: message,
-            messages: obj.chatMessages,
-            toolResultContents: obj.toolResultContents
-          });
-        }
-        let textContent = "";
-        let toolInvocations = [];
-        if (typeof message.content === "string") {
-          textContent = message.content;
-        } else if (typeof message.content === "number") {
-          textContent = String(message.content);
-        } else if (Array.isArray(message.content)) {
-          for (const content of message.content) {
-            if (content.type === "text") {
-              textContent += content.text;
-            } else if (content.type === "tool-call") {
-              const toolResult = obj.toolResultContents.find((tool) => tool.toolCallId === content.toolCallId);
-              toolInvocations.push({
-                state: toolResult ? "result" : "call",
-                toolCallId: content.toolCallId,
-                toolName: content.toolName,
-                args: content.args,
-                result: toolResult?.result
-              });
-            }
-          }
-        }
-        obj.chatMessages.push({
-          id: message.id,
-          role: message.role,
-          content: textContent,
-          toolInvocations
-        });
-        return obj;
-      },
-      { chatMessages: [], toolResultContents: [] }
-    );
-    return chatMessages;
-  }
-  /**
-   * Helper method to create a new thread
-   * @param title - Optional title for the thread
-   * @param metadata - Optional metadata for the thread
-   * @returns Promise resolving to the created thread
-   */
-  async createThread({
-    threadId,
-    resourceId,
-    title,
-    metadata,
-    memoryConfig
-  }) {
-    const thread = {
-      id: threadId || this.generateId(),
-      title: title || `New Thread ${(/* @__PURE__ */ new Date()).toISOString()}`,
-      resourceId,
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date(),
-      metadata
-    };
-    return this.saveThread({ thread, memoryConfig });
-  }
-  /**
-   * Helper method to add a single message to a thread
-   * @param threadId - The thread to add the message to
-   * @param content - The message content
-   * @param role - The role of the message sender
-   * @param type - The type of the message
-   * @param toolNames - Optional array of tool names that were called
-   * @param toolCallArgs - Optional array of tool call arguments
-   * @param toolCallIds - Optional array of tool call ids
-   * @returns Promise resolving to the saved message
-   */
-  async addMessage({
-    threadId,
-    config,
-    content,
-    role,
-    type,
-    toolNames,
-    toolCallArgs,
-    toolCallIds
-  }) {
-    const message = {
-      id: this.generateId(),
-      content,
-      role,
-      createdAt: /* @__PURE__ */ new Date(),
-      threadId,
-      type,
-      toolNames,
-      toolCallArgs,
-      toolCallIds
-    };
-    const savedMessages = await this.saveMessages({ messages: [message], memoryConfig: config });
-    return savedMessages[0];
-  }
-  /**
-   * Generates a unique identifier
-   * @returns A unique string ID
-   */
-  generateId() {
-    return crypto.randomUUID();
-  }
-};
-
-exports.MastraMemory = MastraMemory;