@mastra/lance 0.0.0-working-memory-per-user-20250620161509 → 0.0.0-zod-v4-compat-part-2-20250820135355

package/dist/index.cjs

@@ -1,14 +1,1879 @@
 'use strict';
 
 var lancedb = require('@lancedb/lancedb');
-var agent = require('@mastra/core/agent');
+var error = require('@mastra/core/error');
 var storage = require('@mastra/core/storage');
+var agent = require('@mastra/core/agent');
 var apacheArrow = require('apache-arrow');
 var vector = require('@mastra/core/vector');
 var filter = require('@mastra/core/vector/filter');
 
+// src/storage/index.ts
+var StoreLegacyEvalsLance = class extends storage.LegacyEvalsStorage {
+  client;
+  constructor({ client }) {
+    super();
+    this.client = client;
+  }
+  async getEvalsByAgentName(agentName, type) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_EVALS);
+      const query = table.query().where(`agent_name = '${agentName}'`);
+      const records = await query.toArray();
+      let filteredRecords = records;
+      if (type === "live") {
+        filteredRecords = records.filter((record) => record.test_info === null);
+      } else if (type === "test") {
+        filteredRecords = records.filter((record) => record.test_info !== null);
+      }
+      return filteredRecords.map((record) => {
+        return {
+          id: record.id,
+          input: record.input,
+          output: record.output,
+          agentName: record.agent_name,
+          metricName: record.metric_name,
+          result: JSON.parse(record.result),
+          instructions: record.instructions,
+          testInfo: record.test_info ? JSON.parse(record.test_info) : null,
+          globalRunId: record.global_run_id,
+          runId: record.run_id,
+          createdAt: new Date(record.created_at).toString()
+        };
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_GET_EVALS_BY_AGENT_NAME_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentName }
+        },
+        error$1
+      );
+    }
+  }
+  async getEvals(options) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_EVALS);
+      const conditions = [];
+      if (options.agentName) {
+        conditions.push(`agent_name = '${options.agentName}'`);
+      }
+      if (options.type === "live") {
+        conditions.push("length(test_info) = 0");
+      } else if (options.type === "test") {
+        conditions.push("length(test_info) > 0");
+      }
+      const startDate = options.dateRange?.start || options.fromDate;
+      const endDate = options.dateRange?.end || options.toDate;
+      if (startDate) {
+        conditions.push(`\`created_at\` >= ${startDate.getTime()}`);
+      }
+      if (endDate) {
+        conditions.push(`\`created_at\` <= ${endDate.getTime()}`);
+      }
+      let total = 0;
+      if (conditions.length > 0) {
+        total = await table.countRows(conditions.join(" AND "));
+      } else {
+        total = await table.countRows();
+      }
+      const query = table.query();
+      if (conditions.length > 0) {
+        const whereClause = conditions.join(" AND ");
+        query.where(whereClause);
+      }
+      const records = await query.toArray();
+      const evals = records.sort((a, b) => b.created_at - a.created_at).map((record) => {
+        return {
+          id: record.id,
+          input: record.input,
+          output: record.output,
+          agentName: record.agent_name,
+          metricName: record.metric_name,
+          result: JSON.parse(record.result),
+          instructions: record.instructions,
+          testInfo: record.test_info ? JSON.parse(record.test_info) : null,
+          globalRunId: record.global_run_id,
+          runId: record.run_id,
+          createdAt: new Date(record.created_at).toISOString()
+        };
+      });
+      const page = options.page || 0;
+      const perPage = options.perPage || 10;
+      const pagedEvals = evals.slice(page * perPage, (page + 1) * perPage);
+      return {
+        evals: pagedEvals,
+        total,
+        page,
+        perPage,
+        hasMore: total > (page + 1) * perPage
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_GET_EVALS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentName: options.agentName ?? "" }
+        },
+        error$1
+      );
+    }
+  }
+};
+function getPrimaryKeys(tableName) {
+  let primaryId = ["id"];
+  if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
+    primaryId = ["workflow_name", "run_id"];
+  } else if (tableName === storage.TABLE_EVALS) {
+    primaryId = ["agent_name", "metric_name", "run_id"];
+  }
+  return primaryId;
+}
+function validateKeyTypes(keys, tableSchema) {
+  const fieldTypes = new Map(
+    tableSchema.fields.map((field) => [field.name, field.type?.toString().toLowerCase()])
+  );
+  for (const [key, value] of Object.entries(keys)) {
+    const fieldType = fieldTypes.get(key);
+    if (!fieldType) {
+      throw new Error(`Field '${key}' does not exist in table schema`);
+    }
+    if (value !== null) {
+      if ((fieldType.includes("int") || fieldType.includes("bigint")) && typeof value !== "number") {
+        throw new Error(`Expected numeric value for field '${key}', got ${typeof value}`);
+      }
+      if (fieldType.includes("utf8") && typeof value !== "string") {
+        throw new Error(`Expected string value for field '${key}', got ${typeof value}`);
+      }
+      if (fieldType.includes("timestamp") && !(value instanceof Date) && typeof value !== "string") {
+        throw new Error(`Expected Date or string value for field '${key}', got ${typeof value}`);
+      }
+    }
+  }
+}
+function processResultWithTypeConversion(rawResult, tableSchema) {
+  const fieldTypeMap = /* @__PURE__ */ new Map();
+  tableSchema.fields.forEach((field) => {
+    const fieldName = field.name;
+    const fieldTypeStr = field.type.toString().toLowerCase();
+    fieldTypeMap.set(fieldName, fieldTypeStr);
+  });
+  if (Array.isArray(rawResult)) {
+    return rawResult.map((item) => processResultWithTypeConversion(item, tableSchema));
+  }
+  const processedResult = { ...rawResult };
+  for (const key in processedResult) {
+    const fieldTypeStr = fieldTypeMap.get(key);
+    if (!fieldTypeStr) continue;
+    if (typeof processedResult[key] === "string") {
+      if (fieldTypeStr.includes("int32") || fieldTypeStr.includes("float32")) {
+        if (!isNaN(Number(processedResult[key]))) {
+          processedResult[key] = Number(processedResult[key]);
+        }
+      } else if (fieldTypeStr.includes("int64")) {
+        processedResult[key] = Number(processedResult[key]);
+      } else if (fieldTypeStr.includes("utf8") && key !== "id") {
+        try {
+          const parsed = JSON.parse(processedResult[key]);
+          if (typeof parsed === "object") {
+            processedResult[key] = JSON.parse(processedResult[key]);
+          }
+        } catch {
+        }
+      }
+    } else if (typeof processedResult[key] === "bigint") {
+      processedResult[key] = Number(processedResult[key]);
+    } else if (fieldTypeStr.includes("float64") && ["createdAt", "updatedAt"].includes(key)) {
+      processedResult[key] = new Date(processedResult[key]);
+    }
+    console.log(key, "processedResult", processedResult);
+  }
+  return processedResult;
+}
+async function getTableSchema({
+  tableName,
+  client
+}) {
+  try {
+    if (!client) {
+      throw new Error("LanceDB client not initialized. Call LanceStorage.create() first.");
+    }
+    if (!tableName) {
+      throw new Error("tableName is required for getTableSchema.");
+    }
+  } catch (validationError) {
+    throw new error.MastraError(
+      {
+        id: "STORAGE_LANCE_STORAGE_GET_TABLE_SCHEMA_INVALID_ARGS",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: validationError.message,
+        details: { tableName }
+      },
+      validationError
+    );
+  }
+  try {
+    const table = await client.openTable(tableName);
+    const rawSchema = await table.schema();
+    const fields = rawSchema.fields;
+    return {
+      fields,
+      metadata: /* @__PURE__ */ new Map(),
+      get names() {
+        return fields.map((field) => field.name);
+      }
+    };
+  } catch (error$1) {
+    throw new error.MastraError(
+      {
+        id: "STORAGE_LANCE_STORAGE_GET_TABLE_SCHEMA_FAILED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.THIRD_PARTY,
+        details: { tableName }
+      },
+      error$1
+    );
+  }
+}
+
+// src/storage/domains/memory/index.ts
+var StoreMemoryLance = class extends storage.MemoryStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  async getThreadById({ threadId }) {
+    try {
+      const thread = await this.operations.load({ tableName: storage.TABLE_THREADS, keys: { id: threadId } });
+      if (!thread) {
+        return null;
+      }
+      return {
+        ...thread,
+        createdAt: new Date(thread.createdAt),
+        updatedAt: new Date(thread.updatedAt)
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_GET_THREAD_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getThreadsByResourceId({ resourceId }) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_THREADS);
+      const query = table.query().where(`\`resourceId\` = '${resourceId}'`);
+      const records = await query.toArray();
+      return processResultWithTypeConversion(
+        records,
+        await getTableSchema({ tableName: storage.TABLE_THREADS, client: this.client })
+      );
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * Saves a thread to the database. This function doesn't overwrite existing threads.
+   * @param thread - The thread to save
+   * @returns The saved thread
+   */
+  async saveThread({ thread }) {
+    try {
+      const record = { ...thread, metadata: JSON.stringify(thread.metadata) };
+      const table = await this.client.openTable(storage.TABLE_THREADS);
+      await table.add([record], { mode: "append" });
+      return thread;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_SAVE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    const maxRetries = 5;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        const current = await this.getThreadById({ threadId: id });
+        if (!current) {
+          throw new Error(`Thread with id ${id} not found`);
+        }
+        const mergedMetadata = { ...current.metadata, ...metadata };
+        const record = {
+          id,
+          title,
+          metadata: JSON.stringify(mergedMetadata),
+          updatedAt: (/* @__PURE__ */ new Date()).getTime()
+        };
+        const table = await this.client.openTable(storage.TABLE_THREADS);
+        await table.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute([record]);
+        const updatedThread = await this.getThreadById({ threadId: id });
+        if (!updatedThread) {
+          throw new Error(`Failed to retrieve updated thread ${id}`);
+        }
+        return updatedThread;
+      } catch (error$1) {
+        if (error$1.message?.includes("Commit conflict") && attempt < maxRetries - 1) {
+          const delay = Math.pow(2, attempt) * 10;
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+        throw new error.MastraError(
+          {
+            id: "LANCE_STORE_UPDATE_THREAD_FAILED",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.THIRD_PARTY
+          },
+          error$1
+        );
+      }
+    }
+    throw new error.MastraError(
+      {
+        id: "LANCE_STORE_UPDATE_THREAD_FAILED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.THIRD_PARTY
+      },
+      new Error("All retries exhausted")
+    );
+  }
+  async deleteThread({ threadId }) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_THREADS);
+      await table.delete(`id = '${threadId}'`);
+      const messagesTable = await this.client.openTable(storage.TABLE_MESSAGES);
+      await messagesTable.delete(`thread_id = '${threadId}'`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_DELETE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getMessages({
+    threadId,
+    resourceId,
+    selectBy,
+    format,
+    threadConfig
+  }) {
+    try {
+      if (threadConfig) {
+        throw new Error("ThreadConfig is not supported by LanceDB storage");
+      }
+      const limit = storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
+      const table = await this.client.openTable(storage.TABLE_MESSAGES);
+      let allRecords = [];
+      if (selectBy?.include && selectBy.include.length > 0) {
+        const threadIds = [...new Set(selectBy.include.map((item) => item.threadId))];
+        for (const threadId2 of threadIds) {
+          const threadQuery = table.query().where(`thread_id = '${threadId2}'`);
+          let threadRecords = await threadQuery.toArray();
+          allRecords.push(...threadRecords);
+        }
+      } else {
+        let query = table.query().where(`\`thread_id\` = '${threadId}'`);
+        allRecords = await query.toArray();
+      }
+      allRecords.sort((a, b) => {
+        const dateA = new Date(a.createdAt).getTime();
+        const dateB = new Date(b.createdAt).getTime();
+        return dateA - dateB;
+      });
+      if (selectBy?.include && selectBy.include.length > 0) {
+        allRecords = this.processMessagesWithContext(allRecords, selectBy.include);
+      }
+      if (limit !== Number.MAX_SAFE_INTEGER) {
+        allRecords = allRecords.slice(-limit);
+      }
+      const messages = processResultWithTypeConversion(
+        allRecords,
+        await getTableSchema({ tableName: storage.TABLE_MESSAGES, client: this.client })
+      );
+      const normalized = messages.map((msg) => {
+        const { thread_id, ...rest } = msg;
+        return {
+          ...rest,
+          threadId: thread_id,
+          content: typeof msg.content === "string" ? (() => {
+            try {
+              return JSON.parse(msg.content);
+            } catch {
+              return msg.content;
+            }
+          })() : msg.content
+        };
+      });
+      const list = new agent.MessageList({ threadId, resourceId }).add(normalized, "memory");
+      if (format === "v2") return list.get.all.v2();
+      return list.get.all.v1();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_GET_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async saveMessages(args) {
+    try {
+      const { messages, format = "v1" } = args;
+      if (messages.length === 0) {
+        return [];
+      }
+      const threadId = messages[0]?.threadId;
+      if (!threadId) {
+        throw new Error("Thread ID is required");
+      }
+      for (const message of messages) {
+        if (!message.id) {
+          throw new Error("Message ID is required");
+        }
+        if (!message.threadId) {
+          throw new Error("Thread ID is required for all messages");
+        }
+        if (message.resourceId === null || message.resourceId === void 0) {
+          throw new Error("Resource ID cannot be null or undefined");
+        }
+        if (!message.content) {
+          throw new Error("Message content is required");
+        }
+      }
+      const transformedMessages = messages.map((message) => {
+        const { threadId: threadId2, type, ...rest } = message;
+        return {
+          ...rest,
+          thread_id: threadId2,
+          type: type ?? "v2",
+          content: JSON.stringify(message.content)
+        };
+      });
+      const table = await this.client.openTable(storage.TABLE_MESSAGES);
+      await table.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute(transformedMessages);
+      const threadsTable = await this.client.openTable(storage.TABLE_THREADS);
+      const currentTime = (/* @__PURE__ */ new Date()).getTime();
+      const updateRecord = { id: threadId, updatedAt: currentTime };
+      await threadsTable.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute([updateRecord]);
+      const list = new agent.MessageList().add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_SAVE_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    try {
+      const { resourceId, page = 0, perPage = 10 } = args;
+      const table = await this.client.openTable(storage.TABLE_THREADS);
+      const total = await table.countRows(`\`resourceId\` = '${resourceId}'`);
+      const query = table.query().where(`\`resourceId\` = '${resourceId}'`);
+      const offset = page * perPage;
+      query.limit(perPage);
+      if (offset > 0) {
+        query.offset(offset);
+      }
+      const records = await query.toArray();
+      records.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+      const schema = await getTableSchema({ tableName: storage.TABLE_THREADS, client: this.client });
+      const threads = records.map((record) => processResultWithTypeConversion(record, schema));
+      return {
+        threads,
+        total,
+        page,
+        perPage,
+        hasMore: total > (page + 1) * perPage
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * Processes messages to include context messages based on withPreviousMessages and withNextMessages
+   * @param records - The sorted array of records to process
+   * @param include - The array of include specifications with context parameters
+   * @returns The processed array with context messages included
+   */
+  processMessagesWithContext(records, include) {
+    const messagesWithContext = include.filter((item) => item.withPreviousMessages || item.withNextMessages);
+    if (messagesWithContext.length === 0) {
+      return records;
+    }
+    const messageIndexMap = /* @__PURE__ */ new Map();
+    records.forEach((message, index) => {
+      messageIndexMap.set(message.id, index);
+    });
+    const additionalIndices = /* @__PURE__ */ new Set();
+    for (const item of messagesWithContext) {
+      const messageIndex = messageIndexMap.get(item.id);
+      if (messageIndex !== void 0) {
+        if (item.withPreviousMessages) {
+          const startIdx = Math.max(0, messageIndex - item.withPreviousMessages);
+          for (let i = startIdx; i < messageIndex; i++) {
+            additionalIndices.add(i);
+          }
+        }
+        if (item.withNextMessages) {
+          const endIdx = Math.min(records.length - 1, messageIndex + item.withNextMessages);
+          for (let i = messageIndex + 1; i <= endIdx; i++) {
+            additionalIndices.add(i);
+          }
+        }
+      }
+    }
+    if (additionalIndices.size === 0) {
+      return records;
+    }
+    const originalMatchIds = new Set(include.map((item) => item.id));
+    const allIndices = /* @__PURE__ */ new Set();
+    records.forEach((record, index) => {
+      if (originalMatchIds.has(record.id)) {
+        allIndices.add(index);
+      }
+    });
+    additionalIndices.forEach((index) => {
+      allIndices.add(index);
+    });
+    return Array.from(allIndices).sort((a, b) => a - b).map((index) => records[index]);
+  }
+  async getMessagesPaginated(args) {
+    try {
+      const { threadId, resourceId, selectBy, format = "v1" } = args;
+      if (!threadId) {
+        throw new Error("Thread ID is required for getMessagesPaginated");
+      }
+      const page = selectBy?.pagination?.page ?? 0;
+      const perPage = selectBy?.pagination?.perPage ?? 10;
+      const dateRange = selectBy?.pagination?.dateRange;
+      const fromDate = dateRange?.start;
+      const toDate = dateRange?.end;
+      const table = await this.client.openTable(storage.TABLE_MESSAGES);
+      const messages = [];
+      if (selectBy?.include && Array.isArray(selectBy.include)) {
+        const threadIds = [...new Set(selectBy.include.map((item) => item.threadId))];
+        const allThreadMessages = [];
+        for (const threadId2 of threadIds) {
+          const threadQuery = table.query().where(`thread_id = '${threadId2}'`);
+          let threadRecords = await threadQuery.toArray();
+          if (fromDate) threadRecords = threadRecords.filter((m) => m.createdAt >= fromDate.getTime());
+          if (toDate) threadRecords = threadRecords.filter((m) => m.createdAt <= toDate.getTime());
+          allThreadMessages.push(...threadRecords);
+        }
+        allThreadMessages.sort((a, b) => a.createdAt - b.createdAt);
+        const contextMessages = this.processMessagesWithContext(allThreadMessages, selectBy.include);
+        messages.push(...contextMessages);
+      }
+      const conditions = [`thread_id = '${threadId}'`];
+      if (resourceId) {
+        conditions.push(`\`resourceId\` = '${resourceId}'`);
+      }
+      if (fromDate) {
+        conditions.push(`\`createdAt\` >= ${fromDate.getTime()}`);
+      }
+      if (toDate) {
+        conditions.push(`\`createdAt\` <= ${toDate.getTime()}`);
+      }
+      let total = 0;
+      if (conditions.length > 0) {
+        total = await table.countRows(conditions.join(" AND "));
+      } else {
+        total = await table.countRows();
+      }
+      if (total === 0 && messages.length === 0) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const excludeIds = messages.map((m) => m.id);
+      let selectedMessages = [];
+      if (selectBy?.last && selectBy.last > 0) {
+        const query = table.query();
+        if (conditions.length > 0) {
+          query.where(conditions.join(" AND "));
+        }
+        let records = await query.toArray();
+        records = records.sort((a, b) => a.createdAt - b.createdAt);
+        if (excludeIds.length > 0) {
+          records = records.filter((m) => !excludeIds.includes(m.id));
+        }
+        selectedMessages = records.slice(-selectBy.last);
+      } else {
+        const query = table.query();
+        if (conditions.length > 0) {
+          query.where(conditions.join(" AND "));
+        }
+        let records = await query.toArray();
+        records = records.sort((a, b) => a.createdAt - b.createdAt);
+        if (excludeIds.length > 0) {
+          records = records.filter((m) => !excludeIds.includes(m.id));
+        }
+        selectedMessages = records.slice(page * perPage, (page + 1) * perPage);
+      }
+      const allMessages = [...messages, ...selectedMessages];
+      const seen = /* @__PURE__ */ new Set();
+      const dedupedMessages = allMessages.filter((m) => {
+        const key = `${m.id}:${m.thread_id}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      });
+      const formattedMessages = dedupedMessages.map((msg) => {
+        const { thread_id, ...rest } = msg;
+        return {
+          ...rest,
+          threadId: thread_id,
+          content: typeof msg.content === "string" ? (() => {
+            try {
+              return JSON.parse(msg.content);
+            } catch {
+              return msg.content;
+            }
+          })() : msg.content
+        };
+      });
+      const list = new agent.MessageList().add(formattedMessages, "memory");
+      return {
+        messages: format === "v2" ? list.get.all.v2() : list.get.all.v1(),
+        total,
+        // Total should be the count of messages matching the filters
+        page,
+        perPage,
+        hasMore: total > (page + 1) * perPage
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_GET_MESSAGES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * Parse message data from LanceDB record format to MastraMessageV2 format
+   */
+  parseMessageData(data) {
+    const { thread_id, ...rest } = data;
+    return {
+      ...rest,
+      threadId: thread_id,
+      content: typeof data.content === "string" ? (() => {
+        try {
+          return JSON.parse(data.content);
+        } catch {
+          return data.content;
+        }
+      })() : data.content,
+      createdAt: new Date(data.createdAt),
+      updatedAt: new Date(data.updatedAt)
+    };
+  }
+  async updateMessages(args) {
+    const { messages } = args;
+    this.logger.debug("Updating messages", { count: messages.length });
+    if (!messages.length) {
+      return [];
+    }
+    const updatedMessages = [];
+    const affectedThreadIds = /* @__PURE__ */ new Set();
+    try {
+      for (const updateData of messages) {
+        const { id, ...updates } = updateData;
+        const existingMessage = await this.operations.load({ tableName: storage.TABLE_MESSAGES, keys: { id } });
+        if (!existingMessage) {
+          this.logger.warn("Message not found for update", { id });
+          continue;
+        }
+        const existingMsg = this.parseMessageData(existingMessage);
+        const originalThreadId = existingMsg.threadId;
+        affectedThreadIds.add(originalThreadId);
+        const updatePayload = {};
+        if ("role" in updates && updates.role !== void 0) updatePayload.role = updates.role;
+        if ("type" in updates && updates.type !== void 0) updatePayload.type = updates.type;
+        if ("resourceId" in updates && updates.resourceId !== void 0) updatePayload.resourceId = updates.resourceId;
+        if ("threadId" in updates && updates.threadId !== void 0 && updates.threadId !== null) {
+          updatePayload.thread_id = updates.threadId;
+          affectedThreadIds.add(updates.threadId);
+        }
+        if (updates.content) {
+          const existingContent = existingMsg.content;
+          let newContent = { ...existingContent };
+          if (updates.content.metadata !== void 0) {
+            newContent.metadata = {
+              ...existingContent.metadata || {},
+              ...updates.content.metadata || {}
+            };
+          }
+          if (updates.content.content !== void 0) {
+            newContent.content = updates.content.content;
+          }
+          if ("parts" in updates.content && updates.content.parts !== void 0) {
+            newContent.parts = updates.content.parts;
+          }
+          updatePayload.content = JSON.stringify(newContent);
+        }
+        await this.operations.insert({ tableName: storage.TABLE_MESSAGES, record: { id, ...updatePayload } });
+        const updatedMessage = await this.operations.load({ tableName: storage.TABLE_MESSAGES, keys: { id } });
+        if (updatedMessage) {
+          updatedMessages.push(this.parseMessageData(updatedMessage));
+        }
+      }
+      for (const threadId of affectedThreadIds) {
+        await this.operations.insert({
+          tableName: storage.TABLE_THREADS,
+          record: { id: threadId, updatedAt: Date.now() }
+        });
+      }
+      return updatedMessages;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_UPDATE_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { count: messages.length }
+        },
+        error$1
+      );
+    }
+  }
+  async getResourceById({ resourceId }) {
+    try {
+      const resource = await this.operations.load({ tableName: storage.TABLE_RESOURCES, keys: { id: resourceId } });
+      if (!resource) {
+        return null;
+      }
+      let createdAt;
+      let updatedAt;
+      try {
+        if (resource.createdAt instanceof Date) {
+          createdAt = resource.createdAt;
+        } else if (typeof resource.createdAt === "string") {
+          createdAt = new Date(resource.createdAt);
+        } else if (typeof resource.createdAt === "number") {
+          createdAt = new Date(resource.createdAt);
+        } else {
+          createdAt = /* @__PURE__ */ new Date();
+        }
+        if (isNaN(createdAt.getTime())) {
+          createdAt = /* @__PURE__ */ new Date();
+        }
+      } catch {
+        createdAt = /* @__PURE__ */ new Date();
+      }
+      try {
+        if (resource.updatedAt instanceof Date) {
+          updatedAt = resource.updatedAt;
+        } else if (typeof resource.updatedAt === "string") {
+          updatedAt = new Date(resource.updatedAt);
+        } else if (typeof resource.updatedAt === "number") {
+          updatedAt = new Date(resource.updatedAt);
+        } else {
+          updatedAt = /* @__PURE__ */ new Date();
+        }
+        if (isNaN(updatedAt.getTime())) {
+          updatedAt = /* @__PURE__ */ new Date();
+        }
+      } catch {
+        updatedAt = /* @__PURE__ */ new Date();
+      }
+      let workingMemory = resource.workingMemory;
+      if (workingMemory === null || workingMemory === void 0) {
+        workingMemory = void 0;
+      } else if (workingMemory === "") {
+        workingMemory = "";
+      } else if (typeof workingMemory === "object") {
+        workingMemory = JSON.stringify(workingMemory);
+      }
+      let metadata = resource.metadata;
+      if (metadata === "" || metadata === null || metadata === void 0) {
+        metadata = void 0;
+      } else if (typeof metadata === "string") {
+        try {
+          metadata = JSON.parse(metadata);
+        } catch {
+          metadata = metadata;
+        }
+      }
+      return {
+        ...resource,
+        createdAt,
+        updatedAt,
+        workingMemory,
+        metadata
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_GET_RESOURCE_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async saveResource({ resource }) {
+    try {
+      const record = {
+        ...resource,
+        metadata: resource.metadata ? JSON.stringify(resource.metadata) : "",
+        createdAt: resource.createdAt.getTime(),
+        // Store as timestamp (milliseconds)
+        updatedAt: resource.updatedAt.getTime()
+        // Store as timestamp (milliseconds)
+      };
+      const table = await this.client.openTable(storage.TABLE_RESOURCES);
+      await table.add([record], { mode: "append" });
+      return resource;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_SAVE_RESOURCE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    const maxRetries = 3;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        const existingResource = await this.getResourceById({ resourceId });
+        if (!existingResource) {
+          const newResource = {
+            id: resourceId,
+            workingMemory,
+            metadata: metadata || {},
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date()
+          };
+          return this.saveResource({ resource: newResource });
+        }
+        const updatedResource = {
+          ...existingResource,
+          workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+          metadata: {
+            ...existingResource.metadata,
+            ...metadata
+          },
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        const record = {
+          id: resourceId,
+          workingMemory: updatedResource.workingMemory || "",
+          metadata: updatedResource.metadata ? JSON.stringify(updatedResource.metadata) : "",
+          updatedAt: updatedResource.updatedAt.getTime()
+          // Store as timestamp (milliseconds)
+        };
+        const table = await this.client.openTable(storage.TABLE_RESOURCES);
+        await table.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute([record]);
+        return updatedResource;
+      } catch (error$1) {
+        if (error$1.message?.includes("Commit conflict") && attempt < maxRetries - 1) {
+          const delay = Math.pow(2, attempt) * 10;
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+        throw new error.MastraError(
+          {
+            id: "LANCE_STORE_UPDATE_RESOURCE_FAILED",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.THIRD_PARTY
+          },
+          error$1
+        );
+      }
+    }
+    throw new Error("Unexpected end of retry loop");
+  }
+};
+var StoreOperationsLance = class extends storage.StoreOperations {
+  client;
+  constructor({ client }) {
+    super();
+    this.client = client;
+  }
+  getDefaultValue(type) {
+    switch (type) {
+      case "text":
+        return "''";
+      case "timestamp":
+        return "CURRENT_TIMESTAMP";
+      case "integer":
+      case "bigint":
+        return "0";
+      case "jsonb":
+        return "'{}'";
+      case "uuid":
+        return "''";
+      default:
+        return super.getDefaultValue(type);
+    }
+  }
+  async hasColumn(tableName, columnName) {
+    const table = await this.client.openTable(tableName);
+    const schema = await table.schema();
+    return schema.fields.some((field) => field.name === columnName);
+  }
+  translateSchema(schema) {
+    const fields = Object.entries(schema).map(([name, column]) => {
+      let arrowType;
+      switch (column.type.toLowerCase()) {
+        case "text":
+        case "uuid":
+          arrowType = new apacheArrow.Utf8();
+          break;
+        case "int":
+        case "integer":
+          arrowType = new apacheArrow.Int32();
+          break;
+        case "bigint":
+          arrowType = new apacheArrow.Float64();
+          break;
+        case "float":
+          arrowType = new apacheArrow.Float32();
+          break;
+        case "jsonb":
+        case "json":
+          arrowType = new apacheArrow.Utf8();
+          break;
+        case "binary":
+          arrowType = new apacheArrow.Binary();
+          break;
+        case "timestamp":
+          arrowType = new apacheArrow.Float64();
+          break;
+        default:
+          arrowType = new apacheArrow.Utf8();
+      }
+      return new apacheArrow.Field(name, arrowType, column.nullable ?? true);
+    });
+    return new apacheArrow.Schema(fields);
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    try {
+      if (!this.client) {
+        throw new Error("LanceDB client not initialized. Call LanceStorage.create() first.");
+      }
+      if (!tableName) {
+        throw new Error("tableName is required for createTable.");
+      }
+      if (!schema) {
+        throw new Error("schema is required for createTable.");
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_STORAGE_CREATE_TABLE_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+    try {
+      const arrowSchema = this.translateSchema(schema);
+      await this.client.createEmptyTable(tableName, arrowSchema);
+    } catch (error$1) {
+      if (error$1.message?.includes("already exists")) {
+        this.logger.debug(`Table '${tableName}' already exists, skipping create`);
+        return;
+      }
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_STORAGE_CREATE_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  async dropTable({ tableName }) {
+    try {
+      if (!this.client) {
+        throw new Error("LanceDB client not initialized. Call LanceStorage.create() first.");
+      }
+      if (!tableName) {
+        throw new Error("tableName is required for dropTable.");
+      }
+    } catch (validationError) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_STORAGE_DROP_TABLE_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: validationError.message,
+          details: { tableName }
+        },
+        validationError
+      );
+    }
+    try {
+      await this.client.dropTable(tableName);
+    } catch (error$1) {
+      if (error$1.toString().includes("was not found") || error$1.message?.includes("Table not found")) {
+        this.logger.debug(`Table '${tableName}' does not exist, skipping drop`);
+        return;
+      }
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_STORAGE_DROP_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists
+  }) {
+    try {
+      if (!this.client) {
+        throw new Error("LanceDB client not initialized. Call LanceStorage.create() first.");
+      }
+      if (!tableName) {
+        throw new Error("tableName is required for alterTable.");
+      }
+      if (!schema) {
+        throw new Error("schema is required for alterTable.");
+      }
+      if (!ifNotExists || ifNotExists.length === 0) {
+        this.logger.debug("No columns specified to add in alterTable, skipping.");
+        return;
+      }
+    } catch (validationError) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_STORAGE_ALTER_TABLE_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: validationError.message,
+          details: { tableName }
+        },
+        validationError
+      );
+    }
+    try {
+      const table = await this.client.openTable(tableName);
+      const currentSchema = await table.schema();
+      const existingFields = new Set(currentSchema.fields.map((f) => f.name));
+      const typeMap = {
+        text: "string",
+        integer: "int",
+        bigint: "bigint",
+        timestamp: "timestamp",
+        jsonb: "string",
+        uuid: "string"
+      };
+      const columnsToAdd = ifNotExists.filter((col) => schema[col] && !existingFields.has(col)).map((col) => {
+        const colDef = schema[col];
+        return {
+          name: col,
+          valueSql: colDef?.nullable ? `cast(NULL as ${typeMap[colDef.type ?? "text"]})` : `cast(${this.getDefaultValue(colDef?.type ?? "text")} as ${typeMap[colDef?.type ?? "text"]})`
+        };
+      });
+      if (columnsToAdd.length > 0) {
+        await table.addColumns(columnsToAdd);
+        this.logger?.info?.(`Added columns [${columnsToAdd.map((c) => c.name).join(", ")}] to table ${tableName}`);
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_STORAGE_ALTER_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  async clearTable({ tableName }) {
+    try {
+      if (!this.client) {
+        throw new Error("LanceDB client not initialized. Call LanceStorage.create() first.");
+      }
+      if (!tableName) {
+        throw new Error("tableName is required for clearTable.");
+      }
+    } catch (validationError) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_STORAGE_CLEAR_TABLE_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: validationError.message,
+          details: { tableName }
+        },
+        validationError
+      );
+    }
+    try {
+      const table = await this.client.openTable(tableName);
+      await table.delete("1=1");
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_STORAGE_CLEAR_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  async insert({ tableName, record }) {
+    try {
+      if (!this.client) {
+        throw new Error("LanceDB client not initialized. Call LanceStorage.create() first.");
+      }
+      if (!tableName) {
+        throw new Error("tableName is required for insert.");
+      }
+      if (!record || Object.keys(record).length === 0) {
+        throw new Error("record is required and cannot be empty for insert.");
+      }
+    } catch (validationError) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_STORAGE_INSERT_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: validationError.message,
+          details: { tableName }
+        },
+        validationError
+      );
+    }
+    try {
+      const table = await this.client.openTable(tableName);
+      const primaryId = getPrimaryKeys(tableName);
+      const processedRecord = { ...record };
+      for (const key in processedRecord) {
+        if (processedRecord[key] !== null && typeof processedRecord[key] === "object" && !(processedRecord[key] instanceof Date)) {
+          this.logger.debug("Converting object to JSON string: ", processedRecord[key]);
+          processedRecord[key] = JSON.stringify(processedRecord[key]);
+        }
+      }
+      console.log(await table.schema());
+      await table.mergeInsert(primaryId).whenMatchedUpdateAll().whenNotMatchedInsertAll().execute([processedRecord]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_STORAGE_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  async batchInsert({ tableName, records }) {
+    try {
+      if (!this.client) {
+        throw new Error("LanceDB client not initialized. Call LanceStorage.create() first.");
+      }
+      if (!tableName) {
+        throw new Error("tableName is required for batchInsert.");
+      }
+      if (!records || records.length === 0) {
+        throw new Error("records array is required and cannot be empty for batchInsert.");
+      }
+    } catch (validationError) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_STORAGE_BATCH_INSERT_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: validationError.message,
+          details: { tableName }
+        },
+        validationError
+      );
+    }
+    try {
+      const table = await this.client.openTable(tableName);
+      const primaryId = getPrimaryKeys(tableName);
+      const processedRecords = records.map((record) => {
+        const processedRecord = { ...record };
+        for (const key in processedRecord) {
+          if (processedRecord[key] == null) continue;
+          if (processedRecord[key] !== null && typeof processedRecord[key] === "object" && !(processedRecord[key] instanceof Date)) {
+            processedRecord[key] = JSON.stringify(processedRecord[key]);
+          }
+        }
+        return processedRecord;
+      });
+      console.log(processedRecords);
+      await table.mergeInsert(primaryId).whenMatchedUpdateAll().whenNotMatchedInsertAll().execute(processedRecords);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_STORAGE_BATCH_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  async load({ tableName, keys }) {
+    try {
+      if (!this.client) {
+        throw new Error("LanceDB client not initialized. Call LanceStorage.create() first.");
+      }
+      if (!tableName) {
+        throw new Error("tableName is required for load.");
+      }
+      if (!keys || Object.keys(keys).length === 0) {
+        throw new Error("keys are required and cannot be empty for load.");
+      }
+    } catch (validationError) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_STORAGE_LOAD_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: validationError.message,
+          details: { tableName }
+        },
+        validationError
+      );
+    }
+    try {
+      const table = await this.client.openTable(tableName);
+      const tableSchema = await getTableSchema({ tableName, client: this.client });
+      const query = table.query();
+      if (Object.keys(keys).length > 0) {
+        validateKeyTypes(keys, tableSchema);
+        const filterConditions = Object.entries(keys).map(([key, value]) => {
+          const isCamelCase = /^[a-z][a-zA-Z]*$/.test(key) && /[A-Z]/.test(key);
+          const quotedKey = isCamelCase ? `\`${key}\`` : key;
+          if (typeof value === "string") {
+            return `${quotedKey} = '${value}'`;
+          } else if (value === null) {
+            return `${quotedKey} IS NULL`;
+          } else {
+            return `${quotedKey} = ${value}`;
+          }
+        }).join(" AND ");
+        this.logger.debug("where clause generated: " + filterConditions);
+        query.where(filterConditions);
+      }
+      const result = await query.limit(1).toArray();
+      if (result.length === 0) {
+        this.logger.debug("No record found");
+        return null;
+      }
+      return processResultWithTypeConversion(result[0], tableSchema);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_STORAGE_LOAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName, keyCount: Object.keys(keys).length, firstKey: Object.keys(keys)[0] ?? "" }
+        },
+        error$1
+      );
+    }
+  }
+};
+var StoreScoresLance = class extends storage.ScoresStorage {
+  client;
+  constructor({ client }) {
+    super();
+    this.client = client;
+  }
+  async saveScore(score) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_SCORERS);
+      const schema = await getTableSchema({ tableName: storage.TABLE_SCORERS, client: this.client });
+      const allowedFields = new Set(schema.fields.map((f) => f.name));
+      const filteredScore = {};
+      Object.keys(score).forEach((key) => {
+        if (allowedFields.has(key)) {
+          filteredScore[key] = score[key];
+        }
+      });
+      for (const key in filteredScore) {
+        if (filteredScore[key] !== null && typeof filteredScore[key] === "object" && !(filteredScore[key] instanceof Date)) {
+          filteredScore[key] = JSON.stringify(filteredScore[key]);
+        }
+      }
+      console.log("Saving score to LanceStorage:", filteredScore);
+      await table.add([filteredScore], { mode: "append" });
+      return { score };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORAGE_SAVE_SCORE_FAILED",
+          text: "Failed to save score in LanceStorage",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { error: error$1?.message }
+        },
+        error$1
+      );
+    }
+  }
+  async getScoreById({ id }) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_SCORERS);
+      const query = table.query().where(`id = '${id}'`).limit(1);
+      const records = await query.toArray();
+      if (records.length === 0) return null;
+      const schema = await getTableSchema({ tableName: storage.TABLE_SCORERS, client: this.client });
+      return processResultWithTypeConversion(records[0], schema);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORAGE_GET_SCORE_BY_ID_FAILED",
+          text: "Failed to get score by id in LanceStorage",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { error: error$1?.message }
+        },
+        error$1
+      );
+    }
+  }
+  async getScoresByScorerId({
+    scorerId,
+    pagination
+  }) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_SCORERS);
+      const { page = 0, perPage = 10 } = pagination || {};
+      const offset = page * perPage;
+      const query = table.query().where(`\`scorerId\` = '${scorerId}'`).limit(perPage);
+      if (offset > 0) query.offset(offset);
+      const records = await query.toArray();
+      const schema = await getTableSchema({ tableName: storage.TABLE_SCORERS, client: this.client });
+      const scores = processResultWithTypeConversion(records, schema);
+      const allRecords = await table.query().where(`\`scorerId\` = '${scorerId}'`).toArray();
+      const total = allRecords.length;
+      return {
+        pagination: {
+          page,
+          perPage,
+          total,
+          hasMore: offset + scores.length < total
+        },
+        scores
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORAGE_GET_SCORES_BY_SCORER_ID_FAILED",
+          text: "Failed to get scores by scorerId in LanceStorage",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { error: error$1?.message }
+        },
+        error$1
+      );
+    }
+  }
+  async getScoresByRunId({
+    runId,
+    pagination
+  }) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_SCORERS);
+      const { page = 0, perPage = 10 } = pagination || {};
+      const offset = page * perPage;
+      const query = table.query().where(`\`runId\` = '${runId}'`).limit(perPage);
+      if (offset > 0) query.offset(offset);
+      const records = await query.toArray();
+      const schema = await getTableSchema({ tableName: storage.TABLE_SCORERS, client: this.client });
+      const scores = processResultWithTypeConversion(records, schema);
+      const allRecords = await table.query().where(`\`runId\` = '${runId}'`).toArray();
+      const total = allRecords.length;
+      return {
+        pagination: {
+          page,
+          perPage,
+          total,
+          hasMore: offset + scores.length < total
+        },
+        scores
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORAGE_GET_SCORES_BY_RUN_ID_FAILED",
+          text: "Failed to get scores by runId in LanceStorage",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { error: error$1?.message }
+        },
+        error$1
+      );
+    }
+  }
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_SCORERS);
+      const { page = 0, perPage = 10 } = pagination || {};
+      const offset = page * perPage;
+      const query = table.query().where(`\`entityId\` = '${entityId}' AND \`entityType\` = '${entityType}'`).limit(perPage);
+      if (offset > 0) query.offset(offset);
+      const records = await query.toArray();
+      const schema = await getTableSchema({ tableName: storage.TABLE_SCORERS, client: this.client });
+      const scores = processResultWithTypeConversion(records, schema);
+      const allRecords = await table.query().where(`\`entityId\` = '${entityId}' AND \`entityType\` = '${entityType}'`).toArray();
+      const total = allRecords.length;
+      return {
+        pagination: {
+          page,
+          perPage,
+          total,
+          hasMore: offset + scores.length < total
+        },
+        scores
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORAGE_GET_SCORES_BY_ENTITY_ID_FAILED",
+          text: "Failed to get scores by entityId and entityType in LanceStorage",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { error: error$1?.message }
+        },
+        error$1
+      );
+    }
+  }
+};
+var StoreTracesLance = class extends storage.TracesStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  async saveTrace({ trace }) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_TRACES);
+      const record = {
+        ...trace,
+        attributes: JSON.stringify(trace.attributes),
+        status: JSON.stringify(trace.status),
+        events: JSON.stringify(trace.events),
+        links: JSON.stringify(trace.links),
+        other: JSON.stringify(trace.other)
+      };
+      await table.add([record], { mode: "append" });
+      return trace;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_SAVE_TRACE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getTraceById({ traceId }) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_TRACES);
+      const query = table.query().where(`id = '${traceId}'`);
+      const records = await query.toArray();
+      return records[0];
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_GET_TRACE_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getTraces({
+    name,
+    scope,
+    page = 1,
+    perPage = 10,
+    attributes
+  }) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_TRACES);
+      const query = table.query();
+      if (name) {
+        query.where(`name = '${name}'`);
+      }
+      if (scope) {
+        query.where(`scope = '${scope}'`);
+      }
+      if (attributes) {
+        query.where(`attributes = '${JSON.stringify(attributes)}'`);
+      }
+      const offset = (page - 1) * perPage;
+      query.limit(perPage);
+      if (offset > 0) {
+        query.offset(offset);
+      }
+      const records = await query.toArray();
+      return records.map((record) => {
+        const processed = {
+          ...record,
+          attributes: record.attributes ? JSON.parse(record.attributes) : {},
+          status: record.status ? JSON.parse(record.status) : {},
+          events: record.events ? JSON.parse(record.events) : [],
+          links: record.links ? JSON.parse(record.links) : [],
+          other: record.other ? JSON.parse(record.other) : {},
+          startTime: new Date(record.startTime),
+          endTime: new Date(record.endTime),
+          createdAt: new Date(record.createdAt)
+        };
+        if (processed.parentSpanId === null || processed.parentSpanId === void 0) {
+          processed.parentSpanId = "";
+        } else {
+          processed.parentSpanId = String(processed.parentSpanId);
+        }
+        return processed;
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_GET_TRACES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { name: name ?? "", scope: scope ?? "" }
+        },
+        error$1
+      );
+    }
+  }
+  async getTracesPaginated(args) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_TRACES);
+      const query = table.query();
+      const conditions = [];
+      if (args.name) {
+        conditions.push(`name = '${args.name}'`);
+      }
+      if (args.scope) {
+        conditions.push(`scope = '${args.scope}'`);
+      }
+      if (args.attributes) {
+        const attributesStr = JSON.stringify(args.attributes);
+        conditions.push(`attributes LIKE '%${attributesStr.replace(/"/g, '\\"')}%'`);
+      }
+      if (args.dateRange?.start) {
+        conditions.push(`\`createdAt\` >= ${args.dateRange.start.getTime()}`);
+      }
+      if (args.dateRange?.end) {
+        conditions.push(`\`createdAt\` <= ${args.dateRange.end.getTime()}`);
+      }
+      if (conditions.length > 0) {
+        const whereClause = conditions.join(" AND ");
+        query.where(whereClause);
+      }
+      let total = 0;
+      if (conditions.length > 0) {
+        const countQuery = table.query().where(conditions.join(" AND "));
+        const allRecords = await countQuery.toArray();
+        total = allRecords.length;
+      } else {
+        total = await table.countRows();
+      }
+      const page = args.page || 0;
+      const perPage = args.perPage || 10;
+      const offset = page * perPage;
+      query.limit(perPage);
+      if (offset > 0) {
+        query.offset(offset);
+      }
+      const records = await query.toArray();
+      const traces = records.map((record) => {
+        const processed = {
+          ...record,
+          attributes: record.attributes ? JSON.parse(record.attributes) : {},
+          status: record.status ? JSON.parse(record.status) : {},
+          events: record.events ? JSON.parse(record.events) : [],
+          links: record.links ? JSON.parse(record.links) : [],
+          other: record.other ? JSON.parse(record.other) : {},
+          startTime: new Date(record.startTime),
+          endTime: new Date(record.endTime),
+          createdAt: new Date(record.createdAt)
+        };
+        if (processed.parentSpanId === null || processed.parentSpanId === void 0) {
+          processed.parentSpanId = "";
+        } else {
+          processed.parentSpanId = String(processed.parentSpanId);
+        }
+        return processed;
+      });
+      return {
+        traces,
+        total,
+        page,
+        perPage,
+        hasMore: total > (page + 1) * perPage
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_GET_TRACES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { name: args.name ?? "", scope: args.scope ?? "" }
+        },
+        error$1
+      );
+    }
+  }
+  async batchTraceInsert({ records }) {
+    this.logger.debug("Batch inserting traces", { count: records.length });
+    await this.operations.batchInsert({
+      tableName: storage.TABLE_TRACES,
+      records
+    });
+  }
+};
+function parseWorkflowRun(row) {
+  let parsedSnapshot = row.snapshot;
+  if (typeof parsedSnapshot === "string") {
+    try {
+      parsedSnapshot = JSON.parse(row.snapshot);
+    } catch (e) {
+      console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+    }
+  }
+  return {
+    workflowName: row.workflow_name,
+    runId: row.run_id,
+    snapshot: parsedSnapshot,
+    createdAt: storage.ensureDate(row.createdAt),
+    updatedAt: storage.ensureDate(row.updatedAt),
+    resourceId: row.resourceId
+  };
+}
+var StoreWorkflowsLance = class extends storage.WorkflowsStorage {
+  client;
+  constructor({ client }) {
+    super();
+    this.client = client;
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_WORKFLOW_SNAPSHOT);
+      const query = table.query().where(`workflow_name = '${workflowName}' AND run_id = '${runId}'`);
+      const records = await query.toArray();
+      let createdAt;
+      const now = Date.now();
+      if (records.length > 0) {
+        createdAt = records[0].createdAt ?? now;
+      } else {
+        createdAt = now;
+      }
+      const record = {
+        workflow_name: workflowName,
+        run_id: runId,
+        snapshot: JSON.stringify(snapshot),
+        createdAt,
+        updatedAt: now
+      };
+      await table.mergeInsert(["workflow_name", "run_id"]).whenMatchedUpdateAll().whenNotMatchedInsertAll().execute([record]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error$1
+      );
+    }
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_WORKFLOW_SNAPSHOT);
+      const query = table.query().where(`workflow_name = '${workflowName}' AND run_id = '${runId}'`);
+      const records = await query.toArray();
+      return records.length > 0 ? JSON.parse(records[0].snapshot) : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error$1
+      );
+    }
+  }
+  async getWorkflowRunById(args) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_WORKFLOW_SNAPSHOT);
+      let whereClause = `run_id = '${args.runId}'`;
+      if (args.workflowName) {
+        whereClause += ` AND workflow_name = '${args.workflowName}'`;
+      }
+      const query = table.query().where(whereClause);
+      const records = await query.toArray();
+      if (records.length === 0) return null;
+      const record = records[0];
+      return parseWorkflowRun(record);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { runId: args.runId, workflowName: args.workflowName ?? "" }
+        },
+        error$1
+      );
+    }
+  }
+  async getWorkflowRuns(args) {
+    try {
+      const table = await this.client.openTable(storage.TABLE_WORKFLOW_SNAPSHOT);
+      let query = table.query();
+      const conditions = [];
+      if (args?.workflowName) {
+        conditions.push(`workflow_name = '${args.workflowName.replace(/'/g, "''")}'`);
+      }
+      if (args?.resourceId) {
+        conditions.push(`\`resourceId\` = '${args.resourceId}'`);
+      }
+      if (args?.fromDate instanceof Date) {
+        conditions.push(`\`createdAt\` >= ${args.fromDate.getTime()}`);
+      }
+      if (args?.toDate instanceof Date) {
+        conditions.push(`\`createdAt\` <= ${args.toDate.getTime()}`);
+      }
+      let total = 0;
+      if (conditions.length > 0) {
+        query = query.where(conditions.join(" AND "));
+        total = await table.countRows(conditions.join(" AND "));
+      } else {
+        total = await table.countRows();
+      }
+      if (args?.limit) {
+        query.limit(args.limit);
+      }
+      if (args?.offset) {
+        query.offset(args.offset);
+      }
+      const records = await query.toArray();
+      return {
+        runs: records.map((record) => parseWorkflowRun(record)),
+        total: total || records.length
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "LANCE_STORE_GET_WORKFLOW_RUNS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { namespace: args?.namespace ?? "", workflowName: args?.workflowName ?? "" }
+        },
+        error$1
+      );
+    }
+  }
+};
+
 // src/storage/index.ts
 var LanceStorage = class _LanceStorage extends storage.MastraStorage {
+  stores;
   lanceClient;
   /**
    * Creates a new instance of LanceStorage
@@ -36,9 +1901,27 @@ var LanceStorage = class _LanceStorage extends storage.MastraStorage {
     const instance = new _LanceStorage(name);
     try {
       instance.lanceClient = await lancedb.connect(uri, options);
+      const operations = new StoreOperationsLance({ client: instance.lanceClient });
+      instance.stores = {
+        operations: new StoreOperationsLance({ client: instance.lanceClient }),
+        workflows: new StoreWorkflowsLance({ client: instance.lanceClient }),
+        traces: new StoreTracesLance({ client: instance.lanceClient, operations }),
+        scores: new StoreScoresLance({ client: instance.lanceClient }),
+        memory: new StoreMemoryLance({ client: instance.lanceClient, operations }),
+        legacyEvals: new StoreLegacyEvalsLance({ client: instance.lanceClient })
+      };
       return instance;
     } catch (e) {
-      throw new Error(`Failed to connect to LanceDB: ${e}`);
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_STORAGE_CONNECT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Failed to connect to LanceDB: ${e.message || e}`,
+          details: { uri, optionsProvided: !!options }
+        },
+        e
+      );
     }
   }
   /**
@@ -47,312 +1930,49 @@ var LanceStorage = class _LanceStorage extends storage.MastraStorage {
    */
   constructor(name) {
     super({ name });
+    const operations = new StoreOperationsLance({ client: this.lanceClient });
+    this.stores = {
+      operations: new StoreOperationsLance({ client: this.lanceClient }),
+      workflows: new StoreWorkflowsLance({ client: this.lanceClient }),
+      traces: new StoreTracesLance({ client: this.lanceClient, operations }),
+      scores: new StoreScoresLance({ client: this.lanceClient }),
+      legacyEvals: new StoreLegacyEvalsLance({ client: this.lanceClient }),
+      memory: new StoreMemoryLance({ client: this.lanceClient, operations })
+    };
   }
   async createTable({
     tableName,
     schema
   }) {
-    try {
-      const arrowSchema = this.translateSchema(schema);
-      await this.lanceClient.createEmptyTable(tableName, arrowSchema);
-    } catch (error) {
-      throw new Error(`Failed to create table: ${error}`);
-    }
-  }
-  translateSchema(schema) {
-    const fields = Object.entries(schema).map(([name, column]) => {
-      let arrowType;
-      switch (column.type.toLowerCase()) {
-        case "text":
-        case "uuid":
-          arrowType = new apacheArrow.Utf8();
-          break;
-        case "int":
-        case "integer":
-          arrowType = new apacheArrow.Int32();
-          break;
-        case "bigint":
-          arrowType = new apacheArrow.Float64();
-          break;
-        case "float":
-          arrowType = new apacheArrow.Float32();
-          break;
-        case "jsonb":
-        case "json":
-          arrowType = new apacheArrow.Utf8();
-          break;
-        case "binary":
-          arrowType = new apacheArrow.Binary();
-          break;
-        case "timestamp":
-          arrowType = new apacheArrow.Float64();
-          break;
-        default:
-          arrowType = new apacheArrow.Utf8();
-      }
-      return new apacheArrow.Field(name, arrowType, column.nullable ?? true);
-    });
-    return new apacheArrow.Schema(fields);
-  }
-  /**
-   * Drop a table if it exists
-   * @param tableName Name of the table to drop
-   */
-  async dropTable(tableName) {
-    try {
-      await this.lanceClient.dropTable(tableName);
-    } catch (error) {
-      if (error.toString().includes("was not found")) {
-        this.logger.debug(`Table '${tableName}' does not exist, skipping drop`);
-        return;
-      }
-      throw new Error(`Failed to drop table: ${error}`);
-    }
-  }
-  /**
-   * Get table schema
-   * @param tableName Name of the table
-   * @returns Table schema
-   */
-  async getTableSchema(tableName) {
-    try {
-      const table = await this.lanceClient.openTable(tableName);
-      const rawSchema = await table.schema();
-      const fields = rawSchema.fields;
-      return {
-        fields,
-        metadata: /* @__PURE__ */ new Map(),
-        get names() {
-          return fields.map((field) => field.name);
-        }
-      };
-    } catch (error) {
-      throw new Error(`Failed to get table schema: ${error}`);
-    }
+    return this.stores.operations.createTable({ tableName, schema });
   }
-  getDefaultValue(type) {
-    switch (type) {
-      case "text":
-        return "''";
-      case "timestamp":
-        return "CURRENT_TIMESTAMP";
-      case "integer":
-      case "bigint":
-        return "0";
-      case "jsonb":
-        return "'{}'";
-      case "uuid":
-        return "''";
-      default:
-        return super.getDefaultValue(type);
-    }
+  async dropTable({ tableName }) {
+    return this.stores.operations.dropTable({ tableName });
   }
-  /**
-   * Alters table schema to add columns if they don't exist
-   * @param tableName Name of the table
-   * @param schema Schema of the table
-   * @param ifNotExists Array of column names to add if they don't exist
-   */
   async alterTable({
     tableName,
     schema,
     ifNotExists
   }) {
-    const table = await this.lanceClient.openTable(tableName);
-    const currentSchema = await table.schema();
-    const existingFields = new Set(currentSchema.fields.map((f) => f.name));
-    const typeMap = {
-      text: "string",
-      integer: "int",
-      bigint: "bigint",
-      timestamp: "timestamp",
-      jsonb: "string",
-      uuid: "string"
-    };
-    const columnsToAdd = ifNotExists.filter((col) => schema[col] && !existingFields.has(col)).map((col) => {
-      const colDef = schema[col];
-      return {
-        name: col,
-        valueSql: colDef?.nullable ? `cast(NULL as ${typeMap[colDef.type ?? "text"]})` : `cast(${this.getDefaultValue(colDef?.type ?? "text")} as ${typeMap[colDef?.type ?? "text"]})`
-      };
-    });
-    if (columnsToAdd.length > 0) {
-      await table.addColumns(columnsToAdd);
-      this.logger?.info?.(`Added columns [${columnsToAdd.map((c) => c.name).join(", ")}] to table ${tableName}`);
-    }
+    return this.stores.operations.alterTable({ tableName, schema, ifNotExists });
   }
   async clearTable({ tableName }) {
-    const table = await this.lanceClient.openTable(tableName);
-    await table.delete("1=1");
+    return this.stores.operations.clearTable({ tableName });
   }
-  /**
-   * Insert a single record into a table. This function overwrites the existing record if it exists. Use this function for inserting records into tables with custom schemas.
-   * @param tableName The name of the table to insert into.
-   * @param record The record to insert.
-   */
   async insert({ tableName, record }) {
-    try {
-      const table = await this.lanceClient.openTable(tableName);
-      const processedRecord = { ...record };
-      for (const key in processedRecord) {
-        if (processedRecord[key] !== null && typeof processedRecord[key] === "object" && !(processedRecord[key] instanceof Date)) {
-          this.logger.debug("Converting object to JSON string: ", processedRecord[key]);
-          processedRecord[key] = JSON.stringify(processedRecord[key]);
-        }
-      }
-      await table.add([processedRecord], { mode: "overwrite" });
-    } catch (error) {
-      throw new Error(`Failed to insert record: ${error}`);
-    }
+    return this.stores.operations.insert({ tableName, record });
   }
-  /**
-   * Insert multiple records into a table. This function overwrites the existing records if they exist. Use this function for inserting records into tables with custom schemas.
-   * @param tableName The name of the table to insert into.
-   * @param records The records to insert.
-   */
   async batchInsert({ tableName, records }) {
-    try {
-      const table = await this.lanceClient.openTable(tableName);
-      const processedRecords = records.map((record) => {
-        const processedRecord = { ...record };
-        for (const key in processedRecord) {
-          if (processedRecord[key] == null) continue;
-          if (processedRecord[key] !== null && typeof processedRecord[key] === "object" && !(processedRecord[key] instanceof Date)) {
-            processedRecord[key] = JSON.stringify(processedRecord[key]);
-          }
-        }
-        return processedRecord;
-      });
-      await table.add(processedRecords, { mode: "overwrite" });
-    } catch (error) {
-      throw new Error(`Failed to batch insert records: ${error}`);
-    }
+    return this.stores.operations.batchInsert({ tableName, records });
   }
-  /**
-   * Load a record from the database by its key(s)
-   * @param tableName The name of the table to query
-   * @param keys Record of key-value pairs to use for lookup
-   * @throws Error if invalid types are provided for keys
-   * @returns The loaded record with proper type conversions, or null if not found
-   */
   async load({ tableName, keys }) {
-    try {
-      const table = await this.lanceClient.openTable(tableName);
-      const tableSchema = await this.getTableSchema(tableName);
-      const query = table.query();
-      if (Object.keys(keys).length > 0) {
-        this.validateKeyTypes(keys, tableSchema);
-        const filterConditions = Object.entries(keys).map(([key, value]) => {
-          const isCamelCase = /^[a-z][a-zA-Z]*$/.test(key) && /[A-Z]/.test(key);
-          const quotedKey = isCamelCase ? `\`${key}\`` : key;
-          if (typeof value === "string") {
-            return `${quotedKey} = '${value}'`;
-          } else if (value === null) {
-            return `${quotedKey} IS NULL`;
-          } else {
-            return `${quotedKey} = ${value}`;
-          }
-        }).join(" AND ");
-        this.logger.debug("where clause generated: " + filterConditions);
-        query.where(filterConditions);
-      }
-      const result = await query.limit(1).toArray();
-      if (result.length === 0) {
-        this.logger.debug("No record found");
-        return null;
-      }
-      return this.processResultWithTypeConversion(result[0], tableSchema);
-    } catch (error) {
-      throw new Error(`Failed to load record: ${error}`);
-    }
-  }
-  /**
-   * Validates that key types match the schema definition
-   * @param keys The keys to validate
-   * @param tableSchema The table schema to validate against
-   * @throws Error if a key has an incompatible type
-   */
-  validateKeyTypes(keys, tableSchema) {
-    const fieldTypes = new Map(
-      tableSchema.fields.map((field) => [field.name, field.type?.toString().toLowerCase()])
-    );
-    for (const [key, value] of Object.entries(keys)) {
-      const fieldType = fieldTypes.get(key);
-      if (!fieldType) {
-        throw new Error(`Field '${key}' does not exist in table schema`);
-      }
-      if (value !== null) {
-        if ((fieldType.includes("int") || fieldType.includes("bigint")) && typeof value !== "number") {
-          throw new Error(`Expected numeric value for field '${key}', got ${typeof value}`);
-        }
-        if (fieldType.includes("utf8") && typeof value !== "string") {
-          throw new Error(`Expected string value for field '${key}', got ${typeof value}`);
-        }
-        if (fieldType.includes("timestamp") && !(value instanceof Date) && typeof value !== "string") {
-          throw new Error(`Expected Date or string value for field '${key}', got ${typeof value}`);
-        }
-      }
-    }
-  }
-  /**
-   * Process a database result with appropriate type conversions based on the table schema
-   * @param rawResult The raw result object from the database
-   * @param tableSchema The schema of the table containing type information
-   * @returns Processed result with correct data types
-   */
-  processResultWithTypeConversion(rawResult, tableSchema) {
-    const fieldTypeMap = /* @__PURE__ */ new Map();
-    tableSchema.fields.forEach((field) => {
-      const fieldName = field.name;
-      const fieldTypeStr = field.type.toString().toLowerCase();
-      fieldTypeMap.set(fieldName, fieldTypeStr);
-    });
-    if (Array.isArray(rawResult)) {
-      return rawResult.map((item) => this.processResultWithTypeConversion(item, tableSchema));
-    }
-    const processedResult = { ...rawResult };
-    for (const key in processedResult) {
-      const fieldTypeStr = fieldTypeMap.get(key);
-      if (!fieldTypeStr) continue;
-      if (typeof processedResult[key] === "string") {
-        if (fieldTypeStr.includes("int32") || fieldTypeStr.includes("float32")) {
-          if (!isNaN(Number(processedResult[key]))) {
-            processedResult[key] = Number(processedResult[key]);
-          }
-        } else if (fieldTypeStr.includes("int64")) {
-          processedResult[key] = Number(processedResult[key]);
-        } else if (fieldTypeStr.includes("utf8")) {
-          try {
-            processedResult[key] = JSON.parse(processedResult[key]);
-          } catch (e) {
-            this.logger.debug(`Failed to parse JSON for key ${key}: ${e}`);
-          }
-        }
-      } else if (typeof processedResult[key] === "bigint") {
-        processedResult[key] = Number(processedResult[key]);
-      }
-    }
-    return processedResult;
+    return this.stores.operations.load({ tableName, keys });
   }
-  getThreadById({ threadId }) {
-    try {
-      return this.load({ tableName: storage.TABLE_THREADS, keys: { id: threadId } });
-    } catch (error) {
-      throw new Error(`Failed to get thread by ID: ${error}`);
-    }
+  async getThreadById({ threadId }) {
+    return this.stores.memory.getThreadById({ threadId });
   }
   async getThreadsByResourceId({ resourceId }) {
-    try {
-      const table = await this.lanceClient.openTable(storage.TABLE_THREADS);
-      const query = table.query().where(`\`resourceId\` = '${resourceId}'`);
-      const records = await query.toArray();
-      return this.processResultWithTypeConversion(
-        records,
-        await this.getTableSchema(storage.TABLE_THREADS)
-      );
-    } catch (error) {
-      throw new Error(`Failed to get threads by resource ID: ${error}`);
-    }
+    return this.stores.memory.getThreadsByResourceId({ resourceId });
   }
   /**
    * Saves a thread to the database. This function doesn't overwrite existing threads.
@@ -360,41 +1980,39 @@ var LanceStorage = class _LanceStorage extends storage.MastraStorage {
    * @returns The saved thread
    */
   async saveThread({ thread }) {
-    try {
-      const record = { ...thread, metadata: JSON.stringify(thread.metadata) };
-      const table = await this.lanceClient.openTable(storage.TABLE_THREADS);
-      await table.add([record], { mode: "append" });
-      return thread;
-    } catch (error) {
-      throw new Error(`Failed to save thread: ${error}`);
-    }
+    return this.stores.memory.saveThread({ thread });
   }
   async updateThread({
     id,
     title,
     metadata
   }) {
-    try {
-      const record = { id, title, metadata: JSON.stringify(metadata) };
-      const table = await this.lanceClient.openTable(storage.TABLE_THREADS);
-      await table.add([record], { mode: "overwrite" });
-      const query = table.query().where(`id = '${id}'`);
-      const records = await query.toArray();
-      return this.processResultWithTypeConversion(
-        records[0],
-        await this.getTableSchema(storage.TABLE_THREADS)
-      );
-    } catch (error) {
-      throw new Error(`Failed to update thread: ${error}`);
-    }
+    return this.stores.memory.updateThread({ id, title, metadata });
   }
   async deleteThread({ threadId }) {
-    try {
-      const table = await this.lanceClient.openTable(storage.TABLE_THREADS);
-      await table.delete(`id = '${threadId}'`);
-    } catch (error) {
-      throw new Error(`Failed to delete thread: ${error}`);
-    }
+    return this.stores.memory.deleteThread({ threadId });
+  }
+  get supports() {
+    return {
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: true,
+      createTable: true,
+      deleteMessages: false
+    };
+  }
+  async getResourceById({ resourceId }) {
+    return this.stores.memory.getResourceById({ resourceId });
+  }
+  async saveResource({ resource }) {
+    return this.stores.memory.saveResource({ resource });
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
   }
   /**
    * Processes messages to include context messages based on withPreviousMessages and withNextMessages
@@ -426,337 +2044,103 @@ var LanceStorage = class _LanceStorage extends storage.MastraStorage {
           for (let i = messageIndex + 1; i <= endIdx; i++) {
             additionalIndices.add(i);
           }
-        }
-      }
-    }
-    if (additionalIndices.size === 0) {
-      return records;
-    }
-    const originalMatchIds = new Set(include.map((item) => item.id));
-    const allIndices = /* @__PURE__ */ new Set();
-    records.forEach((record, index) => {
-      if (originalMatchIds.has(record.id)) {
-        allIndices.add(index);
-      }
-    });
-    additionalIndices.forEach((index) => {
-      allIndices.add(index);
-    });
-    return Array.from(allIndices).sort((a, b) => a - b).map((index) => records[index]);
-  }
-  async getMessages({
-    threadId,
-    resourceId,
-    selectBy,
-    format,
-    threadConfig
-  }) {
-    try {
-      if (threadConfig) {
-        throw new Error("ThreadConfig is not supported by LanceDB storage");
-      }
-      const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
-      const table = await this.lanceClient.openTable(storage.TABLE_MESSAGES);
-      let query = table.query().where(`\`threadId\` = '${threadId}'`);
-      if (selectBy) {
-        if (selectBy.include && selectBy.include.length > 0) {
-          const includeIds = selectBy.include.map((item) => item.id);
-          const includeClause = includeIds.map((id) => `\`id\` = '${id}'`).join(" OR ");
-          query = query.where(`(\`threadId\` = '${threadId}' OR (${includeClause}))`);
-        }
-      }
-      let records = await query.toArray();
-      records.sort((a, b) => {
-        const dateA = new Date(a.createdAt).getTime();
-        const dateB = new Date(b.createdAt).getTime();
-        return dateA - dateB;
-      });
-      if (selectBy?.include && selectBy.include.length > 0) {
-        records = this.processMessagesWithContext(records, selectBy.include);
-      }
-      if (limit !== Number.MAX_SAFE_INTEGER) {
-        records = records.slice(-limit);
-      }
-      const messages = this.processResultWithTypeConversion(records, await this.getTableSchema(storage.TABLE_MESSAGES));
-      const normalized = messages.map((msg) => ({
-        ...msg,
-        content: typeof msg.content === "string" ? (() => {
-          try {
-            return JSON.parse(msg.content);
-          } catch {
-            return msg.content;
-          }
-        })() : msg.content
-      }));
-      const list = new agent.MessageList({ threadId, resourceId }).add(normalized, "memory");
-      if (format === "v2") return list.get.all.v2();
-      return list.get.all.v1();
-    } catch (error) {
-      throw new Error(`Failed to get messages: ${error}`);
-    }
-  }
-  async saveMessages(args) {
-    try {
-      const { messages, format = "v1" } = args;
-      if (messages.length === 0) {
-        return [];
-      }
-      const threadId = messages[0]?.threadId;
-      if (!threadId) {
-        throw new Error("Thread ID is required");
+        }
       }
-      const transformedMessages = messages.map((message) => ({
-        ...message,
-        content: JSON.stringify(message.content)
-      }));
-      const table = await this.lanceClient.openTable(storage.TABLE_MESSAGES);
-      await table.add(transformedMessages, { mode: "overwrite" });
-      const list = new agent.MessageList().add(messages, "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
-    } catch (error) {
-      throw new Error(`Failed to save messages: ${error}`);
-    }
-  }
-  async saveTrace({ trace }) {
-    try {
-      const table = await this.lanceClient.openTable(storage.TABLE_TRACES);
-      const record = {
-        ...trace,
-        attributes: JSON.stringify(trace.attributes),
-        status: JSON.stringify(trace.status),
-        events: JSON.stringify(trace.events),
-        links: JSON.stringify(trace.links),
-        other: JSON.stringify(trace.other)
-      };
-      await table.add([record], { mode: "append" });
-      return trace;
-    } catch (error) {
-      throw new Error(`Failed to save trace: ${error}`);
     }
-  }
-  async getTraceById({ traceId }) {
-    try {
-      const table = await this.lanceClient.openTable(storage.TABLE_TRACES);
-      const query = table.query().where(`id = '${traceId}'`);
-      const records = await query.toArray();
-      return this.processResultWithTypeConversion(records[0], await this.getTableSchema(storage.TABLE_TRACES));
-    } catch (error) {
-      throw new Error(`Failed to get trace by ID: ${error}`);
+    if (additionalIndices.size === 0) {
+      return records;
     }
+    const originalMatchIds = new Set(include.map((item) => item.id));
+    const allIndices = /* @__PURE__ */ new Set();
+    records.forEach((record, index) => {
+      if (originalMatchIds.has(record.id)) {
+        allIndices.add(index);
+      }
+    });
+    additionalIndices.forEach((index) => {
+      allIndices.add(index);
+    });
+    return Array.from(allIndices).sort((a, b) => a - b).map((index) => records[index]);
   }
-  async getTraces({
-    name,
-    scope,
-    page = 1,
-    perPage = 10,
-    attributes
+  async getMessages({
+    threadId,
+    resourceId,
+    selectBy,
+    format,
+    threadConfig
   }) {
-    try {
-      const table = await this.lanceClient.openTable(storage.TABLE_TRACES);
-      const query = table.query();
-      if (name) {
-        query.where(`name = '${name}'`);
-      }
-      if (scope) {
-        query.where(`scope = '${scope}'`);
-      }
-      if (attributes) {
-        query.where(`attributes = '${JSON.stringify(attributes)}'`);
-      }
-      const offset = (page - 1) * perPage;
-      query.limit(perPage);
-      if (offset > 0) {
-        query.offset(offset);
-      }
-      const records = await query.toArray();
-      return records.map((record) => {
-        return {
-          ...record,
-          attributes: JSON.parse(record.attributes),
-          status: JSON.parse(record.status),
-          events: JSON.parse(record.events),
-          links: JSON.parse(record.links),
-          other: JSON.parse(record.other),
-          startTime: new Date(record.startTime),
-          endTime: new Date(record.endTime),
-          createdAt: new Date(record.createdAt)
-        };
-      });
-    } catch (error) {
-      throw new Error(`Failed to get traces: ${error}`);
-    }
+    return this.stores.memory.getMessages({ threadId, resourceId, selectBy, format, threadConfig });
   }
-  async saveEvals({ evals }) {
-    try {
-      const table = await this.lanceClient.openTable(storage.TABLE_EVALS);
-      const transformedEvals = evals.map((evalRecord) => ({
-        input: evalRecord.input,
-        output: evalRecord.output,
-        agent_name: evalRecord.agentName,
-        metric_name: evalRecord.metricName,
-        result: JSON.stringify(evalRecord.result),
-        instructions: evalRecord.instructions,
-        test_info: JSON.stringify(evalRecord.testInfo),
-        global_run_id: evalRecord.globalRunId,
-        run_id: evalRecord.runId,
-        created_at: new Date(evalRecord.createdAt).getTime()
-      }));
-      await table.add(transformedEvals, { mode: "append" });
-      return evals;
-    } catch (error) {
-      throw new Error(`Failed to save evals: ${error}`);
-    }
+  async saveMessages(args) {
+    return this.stores.memory.saveMessages(args);
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    return this.stores.memory.getThreadsByResourceIdPaginated(args);
+  }
+  async getMessagesPaginated(args) {
+    return this.stores.memory.getMessagesPaginated(args);
+  }
+  async updateMessages(_args) {
+    return this.stores.memory.updateMessages(_args);
+  }
+  async getTraceById(args) {
+    return this.stores.traces.getTraceById(args);
+  }
+  async getTraces(args) {
+    return this.stores.traces.getTraces(args);
+  }
+  async getTracesPaginated(args) {
+    return this.stores.traces.getTracesPaginated(args);
   }
   async getEvalsByAgentName(agentName, type) {
-    try {
-      if (type) {
-        this.logger.warn("Type is not implemented yet in LanceDB storage");
-      }
-      const table = await this.lanceClient.openTable(storage.TABLE_EVALS);
-      const query = table.query().where(`agent_name = '${agentName}'`);
-      const records = await query.toArray();
-      return records.map((record) => {
-        return {
-          id: record.id,
-          input: record.input,
-          output: record.output,
-          agentName: record.agent_name,
-          metricName: record.metric_name,
-          result: JSON.parse(record.result),
-          instructions: record.instructions,
-          testInfo: JSON.parse(record.test_info),
-          globalRunId: record.global_run_id,
-          runId: record.run_id,
-          createdAt: new Date(record.created_at).toString()
-        };
-      });
-    } catch (error) {
-      throw new Error(`Failed to get evals by agent name: ${error}`);
-    }
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
   }
-  parseWorkflowRun(row) {
-    let parsedSnapshot = row.snapshot;
-    if (typeof parsedSnapshot === "string") {
-      try {
-        parsedSnapshot = JSON.parse(row.snapshot);
-      } catch (e) {
-        console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
-      }
-    }
-    return {
-      workflowName: row.workflow_name,
-      runId: row.run_id,
-      snapshot: parsedSnapshot,
-      createdAt: this.ensureDate(row.createdAt),
-      updatedAt: this.ensureDate(row.updatedAt),
-      resourceId: row.resourceId
-    };
+  async getEvals(options) {
+    return this.stores.legacyEvals.getEvals(options);
   }
   async getWorkflowRuns(args) {
-    try {
-      const table = await this.lanceClient.openTable(storage.TABLE_WORKFLOW_SNAPSHOT);
-      const query = table.query();
-      if (args?.workflowName) {
-        query.where(`workflow_name = '${args.workflowName}'`);
-      }
-      if (args?.fromDate) {
-        query.where(`\`createdAt\` >= ${args.fromDate.getTime()}`);
-      }
-      if (args?.toDate) {
-        query.where(`\`createdAt\` <= ${args.toDate.getTime()}`);
-      }
-      if (args?.limit) {
-        query.limit(args.limit);
-      }
-      if (args?.offset) {
-        query.offset(args.offset);
-      }
-      const records = await query.toArray();
-      return {
-        runs: records.map((record) => this.parseWorkflowRun(record)),
-        total: records.length
-      };
-    } catch (error) {
-      throw new Error(`Failed to get workflow runs: ${error}`);
-    }
+    return this.stores.workflows.getWorkflowRuns(args);
   }
-  /**
-   * Retrieve a single workflow run by its runId.
-   * @param args The ID of the workflow run to retrieve
-   * @returns The workflow run object or null if not found
-   */
   async getWorkflowRunById(args) {
-    try {
-      const table = await this.lanceClient.openTable(storage.TABLE_WORKFLOW_SNAPSHOT);
-      let whereClause = `run_id = '${args.runId}'`;
-      if (args.workflowName) {
-        whereClause += ` AND workflow_name = '${args.workflowName}'`;
-      }
-      const query = table.query().where(whereClause);
-      const records = await query.toArray();
-      if (records.length === 0) return null;
-      const record = records[0];
-      return this.parseWorkflowRun(record);
-    } catch (error) {
-      throw new Error(`Failed to get workflow run by id: ${error}`);
-    }
+    return this.stores.workflows.getWorkflowRunById(args);
   }
   async persistWorkflowSnapshot({
     workflowName,
     runId,
     snapshot
   }) {
-    try {
-      const table = await this.lanceClient.openTable(storage.TABLE_WORKFLOW_SNAPSHOT);
-      const query = table.query().where(`workflow_name = '${workflowName}' AND run_id = '${runId}'`);
-      const records = await query.toArray();
-      let createdAt;
-      const now = Date.now();
-      let mode = "append";
-      if (records.length > 0) {
-        createdAt = records[0].createdAt ?? now;
-        mode = "overwrite";
-      } else {
-        createdAt = now;
-      }
-      const record = {
-        workflow_name: workflowName,
-        run_id: runId,
-        snapshot: JSON.stringify(snapshot),
-        createdAt,
-        updatedAt: now
-      };
-      await table.add([record], { mode });
-    } catch (error) {
-      throw new Error(`Failed to persist workflow snapshot: ${error}`);
-    }
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
   }
   async loadWorkflowSnapshot({
     workflowName,
     runId
   }) {
-    try {
-      const table = await this.lanceClient.openTable(storage.TABLE_WORKFLOW_SNAPSHOT);
-      const query = table.query().where(`workflow_name = '${workflowName}' AND run_id = '${runId}'`);
-      const records = await query.toArray();
-      return records.length > 0 ? JSON.parse(records[0].snapshot) : null;
-    } catch (error) {
-      throw new Error(`Failed to load workflow snapshot: ${error}`);
-    }
+    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
+  }
+  async getScoreById({ id: _id }) {
+    return this.stores.scores.getScoreById({ id: _id });
   }
-  async getTracesPaginated(_args) {
-    throw new Error("Method not implemented.");
+  async getScoresByScorerId({
+    scorerId,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByScorerId({ scorerId, pagination });
   }
-  async getThreadsByResourceIdPaginated(_args) {
-    throw new Error("Method not implemented.");
+  async saveScore(_score) {
+    return this.stores.scores.saveScore(_score);
   }
-  async getMessagesPaginated(_args) {
-    throw new Error("Method not implemented.");
+  async getScoresByRunId({
+    runId,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByRunId({ runId, pagination });
   }
-  async updateMessages(_args) {
-    this.logger.error("updateMessages is not yet implemented in LanceStore");
-    throw new Error("Method not implemented");
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByEntityId({ entityId, entityType, pagination });
   }
 };
 var LanceFilterTranslator = class extends filter.BaseFilterTranslator {
@@ -1110,7 +2494,15 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
       instance.lanceClient = await lancedb.connect(uri, options);
       return instance;
     } catch (e) {
-      throw new Error(`Failed to connect to LanceDB: ${e}`);
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_CONNECT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { uri }
+        },
+        e
+      );
     }
   }
   /**
@@ -1134,14 +2526,27 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
     columns = [],
     includeAllColumns = false
   }) {
-    if (!this.lanceClient) {
-      throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
-    }
-    if (!tableName) {
-      throw new Error("tableName is required");
-    }
-    if (!queryVector) {
-      throw new Error("queryVector is required");
+    try {
+      if (!this.lanceClient) {
+        throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
+      }
+      if (!tableName) {
+        throw new Error("tableName is required");
+      }
+      if (!queryVector) {
+        throw new Error("queryVector is required");
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_QUERY_FAILED_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: "LanceDB client not initialized. Use LanceVectorStore.create() to create an instance",
+          details: { tableName }
+        },
+        error$1
+      );
     }
     try {
       const table = await this.lanceClient.openTable(tableName);
@@ -1179,8 +2584,16 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
           score: result._distance
         };
       });
-    } catch (error) {
-      throw new Error(`Failed to query vectors: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_QUERY_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName, includeVector, columnsCount: columns?.length, includeAllColumns }
+        },
+        error$1
+      );
     }
   }
   filterTranslator(filter) {
@@ -1213,14 +2626,27 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
     return translator.translate(prefixedFilter);
   }
   async upsert({ tableName, vectors, metadata = [], ids = [] }) {
-    if (!this.lanceClient) {
-      throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
-    }
-    if (!tableName) {
-      throw new Error("tableName is required");
-    }
-    if (!vectors || !Array.isArray(vectors) || vectors.length === 0) {
-      throw new Error("vectors array is required and must not be empty");
+    try {
+      if (!this.lanceClient) {
+        throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
+      }
+      if (!tableName) {
+        throw new Error("tableName is required");
+      }
+      if (!vectors || !Array.isArray(vectors) || vectors.length === 0) {
+        throw new Error("vectors array is required and must not be empty");
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_UPSERT_FAILED_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: "LanceDB client not initialized. Use LanceVectorStore.create() to create an instance",
+          details: { tableName }
+        },
+        error$1
+      );
     }
     try {
       const tables = await this.lanceClient.tableNames();
@@ -1246,8 +2672,16 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
       });
       await table.add(data, { mode: "overwrite" });
       return vectorIds;
-    } catch (error) {
-      throw new Error(`Failed to upsert vectors: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_UPSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName, vectorCount: vectors.length, metadataCount: metadata.length, idsCount: ids.length }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -1267,29 +2701,78 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
   }
   async createTable(tableName, data, options) {
     if (!this.lanceClient) {
-      throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
+      throw new error.MastraError({
+        id: "STORAGE_LANCE_VECTOR_CREATE_TABLE_FAILED_INVALID_ARGS",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: "LanceDB client not initialized. Use LanceVectorStore.create() to create an instance",
+        details: { tableName }
+      });
+    }
+    if (Array.isArray(data)) {
+      data = data.map((record) => this.flattenObject(record));
     }
     try {
-      if (Array.isArray(data)) {
-        data = data.map((record) => this.flattenObject(record));
-      }
       return await this.lanceClient.createTable(tableName, data, options);
-    } catch (error) {
-      throw new Error(`Failed to create table: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_CREATE_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
     }
   }
   async listTables() {
     if (!this.lanceClient) {
-      throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
+      throw new error.MastraError({
+        id: "STORAGE_LANCE_VECTOR_LIST_TABLES_FAILED_INVALID_ARGS",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: "LanceDB client not initialized. Use LanceVectorStore.create() to create an instance",
+        details: { methodName: "listTables" }
+      });
+    }
+    try {
+      return await this.lanceClient.tableNames();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_LIST_TABLES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
     }
-    return await this.lanceClient.tableNames();
   }
   async getTableSchema(tableName) {
     if (!this.lanceClient) {
-      throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
+      throw new error.MastraError({
+        id: "STORAGE_LANCE_VECTOR_GET_TABLE_SCHEMA_FAILED_INVALID_ARGS",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: "LanceDB client not initialized. Use LanceVectorStore.create() to create an instance",
+        details: { tableName }
+      });
+    }
+    try {
+      const table = await this.lanceClient.openTable(tableName);
+      return await table.schema();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_GET_TABLE_SCHEMA_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
     }
-    const table = await this.lanceClient.openTable(tableName);
-    return await table.schema();
   }
   /**
    * indexName is actually a column name in a table in lanceDB
@@ -1301,10 +2784,10 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
     metric = "cosine",
     indexConfig = {}
   }) {
-    if (!this.lanceClient) {
-      throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
-    }
     try {
+      if (!this.lanceClient) {
+        throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
+      }
       if (!tableName) {
         throw new Error("tableName is required");
       }
@@ -1314,6 +2797,18 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
       if (typeof dimension !== "number" || dimension <= 0) {
         throw new Error("dimension must be a positive number");
       }
+    } catch (err) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_CREATE_INDEX_FAILED_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { tableName: tableName || "", indexName, dimension, metric }
+        },
+        err
+      );
+    }
+    try {
       const tables = await this.lanceClient.tableNames();
       if (!tables.includes(tableName)) {
         throw new Error(
@@ -1347,13 +2842,27 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
           })
         });
       }
-    } catch (error) {
-      throw new Error(`Failed to create index: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_CREATE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName: tableName || "", indexName, dimension }
+        },
+        error$1
+      );
     }
   }
   async listIndexes() {
     if (!this.lanceClient) {
-      throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
+      throw new error.MastraError({
+        id: "STORAGE_LANCE_VECTOR_LIST_INDEXES_FAILED_INVALID_ARGS",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: "LanceDB client not initialized. Use LanceVectorStore.create() to create an instance",
+        details: { methodName: "listIndexes" }
+      });
     }
     try {
       const tables = await this.lanceClient.tableNames();
@@ -1364,16 +2873,35 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
         allIndices.push(...tableIndices.map((index) => index.name));
       }
       return allIndices;
-    } catch (error) {
-      throw new Error(`Failed to list indexes: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_LIST_INDEXES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
     }
   }
   async describeIndex({ indexName }) {
-    if (!this.lanceClient) {
-      throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
-    }
-    if (!indexName) {
-      throw new Error("indexName is required");
+    try {
+      if (!this.lanceClient) {
+        throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
+      }
+      if (!indexName) {
+        throw new Error("indexName is required");
+      }
+    } catch (err) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_DESCRIBE_INDEX_FAILED_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName }
+        },
+        err
+      );
     }
     try {
       const tables = await this.lanceClient.tableNames();
@@ -1399,16 +2927,36 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
         }
       }
       throw new Error(`IndexName: ${indexName} not found`);
-    } catch (error) {
-      throw new Error(`Failed to describe index: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
     }
   }
   async deleteIndex({ indexName }) {
-    if (!this.lanceClient) {
-      throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
-    }
-    if (!indexName) {
-      throw new Error("indexName is required");
+    try {
+      if (!this.lanceClient) {
+        throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
+      }
+      if (!indexName) {
+        throw new Error("indexName is required");
+      }
+    } catch (err) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_DELETE_INDEX_FAILED_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName }
+        },
+        err
+      );
     }
     try {
       const tables = await this.lanceClient.tableNames();
@@ -1422,8 +2970,16 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
         }
       }
       throw new Error(`Index ${indexName} not found`);
-    } catch (error) {
-      throw new Error(`Failed to delete index: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_DELETE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -1431,33 +2987,73 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
    */
   async deleteAllTables() {
     if (!this.lanceClient) {
-      throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
+      throw new error.MastraError({
+        id: "STORAGE_LANCE_VECTOR_DELETE_ALL_TABLES_FAILED_INVALID_ARGS",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { methodName: "deleteAllTables" },
+        text: "LanceDB client not initialized. Use LanceVectorStore.create() to create an instance"
+      });
     }
     try {
       await this.lanceClient.dropAllTables();
-    } catch (error) {
-      throw new Error(`Failed to delete tables: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_DELETE_ALL_TABLES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { methodName: "deleteAllTables" }
+        },
+        error$1
+      );
     }
   }
   async deleteTable(tableName) {
     if (!this.lanceClient) {
-      throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
+      throw new error.MastraError({
+        id: "STORAGE_LANCE_VECTOR_DELETE_TABLE_FAILED_INVALID_ARGS",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { tableName },
+        text: "LanceDB client not initialized. Use LanceVectorStore.create() to create an instance"
+      });
     }
     try {
       await this.lanceClient.dropTable(tableName);
-    } catch (error) {
-      throw new Error(`Failed to delete tables: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_DELETE_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
     }
   }
   async updateVector({ indexName, id, update }) {
-    if (!this.lanceClient) {
-      throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
-    }
-    if (!indexName) {
-      throw new Error("indexName is required");
-    }
-    if (!id) {
-      throw new Error("id is required");
+    try {
+      if (!this.lanceClient) {
+        throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
+      }
+      if (!indexName) {
+        throw new Error("indexName is required");
+      }
+      if (!id) {
+        throw new Error("id is required");
+      }
+    } catch (err) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_UPDATE_VECTOR_FAILED_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName, id }
+        },
+        err
+      );
     }
     try {
       const tables = await this.lanceClient.tableNames();
@@ -1510,19 +3106,39 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
         }
       }
       throw new Error(`No table found with column/index '${indexName}'`);
-    } catch (error) {
-      throw new Error(`Failed to update index: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_UPDATE_VECTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, id, hasVector: !!update.vector, hasMetadata: !!update.metadata }
+        },
+        error$1
+      );
     }
   }
   async deleteVector({ indexName, id }) {
-    if (!this.lanceClient) {
-      throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
-    }
-    if (!indexName) {
-      throw new Error("indexName is required");
-    }
-    if (!id) {
-      throw new Error("id is required");
+    try {
+      if (!this.lanceClient) {
+        throw new Error("LanceDB client not initialized. Use LanceVectorStore.create() to create an instance");
+      }
+      if (!indexName) {
+        throw new Error("indexName is required");
+      }
+      if (!id) {
+        throw new Error("id is required");
+      }
+    } catch (err) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_DELETE_VECTOR_FAILED_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName, id }
+        },
+        err
+      );
     }
     try {
       const tables = await this.lanceClient.tableNames();
@@ -1543,8 +3159,16 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
         }
       }
       throw new Error(`No table found with column/index '${indexName}'`);
-    } catch (error) {
-      throw new Error(`Failed to delete index: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_LANCE_VECTOR_DELETE_VECTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -1576,3 +3200,5 @@ var LanceVectorStore = class _LanceVectorStore extends vector.MastraVector {
 
 exports.LanceStorage = LanceStorage;
 exports.LanceVectorStore = LanceVectorStore;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map