@mastra/core 0.0.0-commonjs-20250227130920

package/dist/memory/index.cjs

@@ -0,0 +1,1907 @@
+'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 ai = require('ai');
+var node_modulesPath = require('node_modules-path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var pino__default = /*#__PURE__*/_interopDefault(pino);
+var pretty__default = /*#__PURE__*/_interopDefault(pretty);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var node_modulesPath__default = /*#__PURE__*/_interopDefault(node_modulesPath);
+
+// src/logger/index.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
+      },
+      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;
+  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 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");
+      }
+    }
+  }
+});
+var defaultEmbedder = fastEmbedProvider.textEmbeddingModel;
+
+// src/vector/index.ts
+var MastraVector = class extends MastraBase {
+  constructor() {
+    super({ name: "MastraVector", component: "VECTOR" });
+  }
+};
+
+// src/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
+    });
+  }
+  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;
+  }
+  transformFilter(filter) {
+    const libsqlFilter = new LibSQLFilterTranslator();
+    const translatedFilter = libsqlFilter.translate(filter ?? {});
+    return translatedFilter;
+  }
+  async query(indexName, queryVector, topK = 10, filter, includeVector = false, minScore = 0) {
+    try {
+      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(indexName, vectors, metadata, ids) {
+    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(indexName, dimension, _metric = "cosine") {
+    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}`);
+    }
+  }
+  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
+  };
+  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 {
+      this.vector = new LibSQLVector({
+        connectionUrl: "file:memory-vector.db"
+        // file name needs to be different than default storage or it wont work properly
+      });
+    }
+    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;
+  }
+  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, 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) : 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 (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",
+      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;