@mastra/lance 0.0.0-netlify-no-bundle-20251127120354 → 0.0.0-partial-response-backport-20251204204441

package/dist/index.js

@@ -1,17 +1,133 @@
 import { connect, Index } from '@lancedb/lancedb';
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
-import { MastraStorage, StoreOperations, MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, normalizePerPage, calculatePagination, TABLE_RESOURCES, ScoresStorage, TABLE_SCORERS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, ensureDate } from '@mastra/core/storage';
+import { MastraStorage, StoreOperations, LegacyEvalsStorage, TABLE_EVALS, MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, resolveMessageLimit, TABLE_RESOURCES, ScoresStorage, TABLE_SCORERS, TracesStorage, TABLE_TRACES, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, ensureDate } from '@mastra/core/storage';
 import { MessageList } from '@mastra/core/agent';
 import { Utf8, Float64, Binary, Float32, Int32, Field, Schema } from 'apache-arrow';
-import { saveScorePayloadSchema } from '@mastra/core/evals';
+import { saveScorePayloadSchema } from '@mastra/core/scores';
 import { MastraVector } from '@mastra/core/vector';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
 // src/storage/index.ts
+var StoreLegacyEvalsLance = class extends LegacyEvalsStorage {
+  client;
+  constructor({ client }) {
+    super();
+    this.client = client;
+  }
+  async getEvalsByAgentName(agentName, type) {
+    try {
+      const table = await this.client.openTable(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) {
+      throw new MastraError(
+        {
+          id: "LANCE_STORE_GET_EVALS_BY_AGENT_NAME_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentName }
+        },
+        error
+      );
+    }
+  }
+  async getEvals(options) {
+    try {
+      const table = await this.client.openTable(TABLE_EVALS);
+      const conditions = [];
+      if (options.agentName) {
+        conditions.push(`agent_name = '${options.agentName}'`);
+      }
+      if (options.type === "live") {
+        conditions.push("test_info IS NULL");
+      } else if (options.type === "test") {
+        conditions.push("test_info IS NOT NULL");
+      }
+      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) {
+      throw new MastraError(
+        {
+          id: "LANCE_STORE_GET_EVALS_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentName: options.agentName ?? "" }
+        },
+        error
+      );
+    }
+  }
+};
 function getPrimaryKeys(tableName) {
   let primaryId = ["id"];
   if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
     primaryId = ["workflow_name", "run_id"];
+  } else if (tableName === TABLE_EVALS) {
+    primaryId = ["agent_name", "metric_name", "run_id"];
   }
   return primaryId;
 }
@@ -131,10 +247,6 @@ var StoreMemoryLance = class extends MemoryStorage {
     this.client = client;
     this.operations = operations;
   }
-  // Utility to escape single quotes in SQL strings
-  escapeSql(str) {
-    return str.replace(/'/g, "''");
-  }
   async getThreadById({ threadId }) {
     try {
       const thread = await this.operations.load({ tableName: TABLE_THREADS, keys: { id: threadId } });
@@ -157,6 +269,26 @@ var StoreMemoryLance = class extends MemoryStorage {
       );
     }
   }
+  async getThreadsByResourceId({ resourceId }) {
+    try {
+      const table = await this.client.openTable(TABLE_THREADS);
+      const query = table.query().where(`\`resourceId\` = '${resourceId}'`);
+      const records = await query.toArray();
+      return processResultWithTypeConversion(
+        records,
+        await getTableSchema({ tableName: TABLE_THREADS, client: this.client })
+      );
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "LANCE_STORE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
   /**
    * Saves a thread to the database. This function doesn't overwrite existing threads.
    * @param thread - The thread to save
@@ -261,174 +393,100 @@ var StoreMemoryLance = class extends MemoryStorage {
       })() : message.content
     };
   }
-  async listMessagesById({ messageIds }) {
-    if (messageIds.length === 0) return { messages: [] };
+  async getMessages({
+    threadId,
+    resourceId,
+    selectBy,
+    format,
+    threadConfig
+  }) {
     try {
+      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
+      if (threadConfig) {
+        throw new Error("ThreadConfig is not supported by LanceDB storage");
+      }
+      const limit = resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
       const table = await this.client.openTable(TABLE_MESSAGES);
-      const quotedIds = messageIds.map((id) => `'${id}'`).join(", ");
-      const allRecords = await table.query().where(`id IN (${quotedIds})`).toArray();
+      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: TABLE_MESSAGES, client: this.client })
       );
-      const list = new MessageList().add(
-        messages.map(this.normalizeMessage),
-        "memory"
-      );
-      return { messages: list.get.all.db() };
+      const list = new MessageList({ threadId, resourceId }).add(messages.map(this.normalizeMessage), "memory");
+      if (format === "v2") return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
       throw new MastraError(
         {
-          id: "LANCE_STORE_LIST_MESSAGES_BY_ID_FAILED",
+          id: "LANCE_STORE_GET_MESSAGES_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
-            messageIds: JSON.stringify(messageIds)
+            threadId,
+            resourceId: resourceId ?? ""
           }
         },
         error
       );
     }
   }
-  async listMessages(args) {
-    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
-    if (!threadId.trim()) {
-      throw new MastraError(
-        {
-          id: "STORAGE_LANCE_LIST_MESSAGES_INVALID_THREAD_ID",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { threadId }
-        },
-        new Error("threadId must be a non-empty string")
-      );
-    }
-    const perPage = normalizePerPage(perPageInput, 40);
-    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+  async getMessagesById({
+    messageIds,
+    format
+  }) {
+    if (messageIds.length === 0) return [];
     try {
-      if (page < 0) {
-        throw new MastraError(
-          {
-            id: "STORAGE_LANCE_LIST_MESSAGES_INVALID_PAGE",
-            domain: ErrorDomain.STORAGE,
-            category: ErrorCategory.USER,
-            details: { page }
-          },
-          new Error("page must be >= 0")
-        );
-      }
-      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
       const table = await this.client.openTable(TABLE_MESSAGES);
-      const conditions = [`thread_id = '${this.escapeSql(threadId)}'`];
-      if (resourceId) {
-        conditions.push(`\`resourceId\` = '${this.escapeSql(resourceId)}'`);
-      }
-      if (filter?.dateRange?.start) {
-        const startTime = filter.dateRange.start instanceof Date ? filter.dateRange.start.getTime() : new Date(filter.dateRange.start).getTime();
-        conditions.push(`\`createdAt\` >= ${startTime}`);
-      }
-      if (filter?.dateRange?.end) {
-        const endTime = filter.dateRange.end instanceof Date ? filter.dateRange.end.getTime() : new Date(filter.dateRange.end).getTime();
-        conditions.push(`\`createdAt\` <= ${endTime}`);
-      }
-      const whereClause = conditions.join(" AND ");
-      const total = await table.countRows(whereClause);
-      const query = table.query().where(whereClause);
-      let allRecords = await query.toArray();
-      allRecords.sort((a, b) => {
-        const aValue = field === "createdAt" ? a.createdAt : a[field];
-        const bValue = field === "createdAt" ? b.createdAt : b[field];
-        if (aValue == null && bValue == null) return 0;
-        if (aValue == null) return direction === "ASC" ? -1 : 1;
-        if (bValue == null) return direction === "ASC" ? 1 : -1;
-        if (typeof aValue === "string" && typeof bValue === "string") {
-          return direction === "ASC" ? aValue.localeCompare(bValue) : bValue.localeCompare(aValue);
-        }
-        return direction === "ASC" ? aValue - bValue : bValue - aValue;
-      });
-      const paginatedRecords = allRecords.slice(offset, offset + perPage);
-      const messages = paginatedRecords.map((row) => this.normalizeMessage(row));
-      if (total === 0 && messages.length === 0 && (!include || include.length === 0)) {
-        return {
-          messages: [],
-          total: 0,
-          page,
-          perPage: perPageForResponse,
-          hasMore: false
-        };
-      }
-      const messageIds = new Set(messages.map((m) => m.id));
-      if (include && include.length > 0) {
-        const threadIds = [...new Set(include.map((item) => item.threadId || threadId))];
-        const allThreadMessages = [];
-        for (const tid of threadIds) {
-          const threadQuery = table.query().where(`thread_id = '${tid}'`);
-          let threadRecords = await threadQuery.toArray();
-          allThreadMessages.push(...threadRecords);
-        }
-        allThreadMessages.sort((a, b) => a.createdAt - b.createdAt);
-        const contextMessages = this.processMessagesWithContext(allThreadMessages, include);
-        const includedMessages = contextMessages.map((row) => this.normalizeMessage(row));
-        for (const includeMsg of includedMessages) {
-          if (!messageIds.has(includeMsg.id)) {
-            messages.push(includeMsg);
-            messageIds.add(includeMsg.id);
-          }
-        }
-      }
-      const list = new MessageList().add(messages, "memory");
-      let finalMessages = list.get.all.db();
-      finalMessages = finalMessages.sort((a, b) => {
-        const aValue = field === "createdAt" ? new Date(a.createdAt).getTime() : a[field];
-        const bValue = field === "createdAt" ? new Date(b.createdAt).getTime() : b[field];
-        if (aValue == null && bValue == null) return 0;
-        if (aValue == null) return direction === "ASC" ? -1 : 1;
-        if (bValue == null) return direction === "ASC" ? 1 : -1;
-        if (typeof aValue === "string" && typeof bValue === "string") {
-          return direction === "ASC" ? aValue.localeCompare(bValue) : bValue.localeCompare(aValue);
-        }
-        return direction === "ASC" ? aValue - bValue : bValue - aValue;
-      });
-      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
-      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
-      const fetchedAll = perPageInput === false || allThreadMessagesReturned;
-      const hasMore = !fetchedAll && offset + perPage < total;
-      return {
-        messages: finalMessages,
-        total,
-        page,
-        perPage: perPageForResponse,
-        hasMore
-      };
+      const quotedIds = messageIds.map((id) => `'${id}'`).join(", ");
+      const allRecords = await table.query().where(`id IN (${quotedIds})`).toArray();
+      const messages = processResultWithTypeConversion(
+        allRecords,
+        await getTableSchema({ tableName: TABLE_MESSAGES, client: this.client })
+      );
+      const list = new MessageList().add(messages.map(this.normalizeMessage), "memory");
+      if (format === `v1`) return list.get.all.v1();
+      return list.get.all.v2();
     } catch (error) {
-      const mastraError = new MastraError(
+      throw new MastraError(
         {
-          id: "LANCE_STORE_LIST_MESSAGES_FAILED",
+          id: "LANCE_STORE_GET_MESSAGES_BY_ID_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
-            threadId,
-            resourceId: resourceId ?? ""
+            messageIds: JSON.stringify(messageIds)
           }
         },
         error
       );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException?.(mastraError);
-      return {
-        messages: [],
-        total: 0,
-        page,
-        perPage: perPageForResponse,
-        hasMore: false
-      };
     }
   }
   async saveMessages(args) {
     try {
-      const { messages } = args;
+      const { messages, format = "v1" } = args;
       if (messages.length === 0) {
-        return { messages: [] };
+        return [];
       }
       const threadId = messages[0]?.threadId;
       if (!threadId) {
@@ -464,7 +522,8 @@ var StoreMemoryLance = class extends MemoryStorage {
       const updateRecord = { id: threadId, updatedAt: currentTime };
       await threadsTable.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute([updateRecord]);
       const list = new MessageList().add(messages, "memory");
-      return { messages: list.get.all.db() };
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
       throw new MastraError(
         {
@@ -476,54 +535,32 @@ var StoreMemoryLance = class extends MemoryStorage {
       );
     }
   }
-  async listThreadsByResourceId(args) {
+  async getThreadsByResourceIdPaginated(args) {
     try {
-      const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
-      const perPage = normalizePerPage(perPageInput, 100);
-      if (page < 0) {
-        throw new MastraError(
-          {
-            id: "STORAGE_LANCE_LIST_THREADS_BY_RESOURCE_ID_INVALID_PAGE",
-            domain: ErrorDomain.STORAGE,
-            category: ErrorCategory.USER,
-            details: { page }
-          },
-          new Error("page must be >= 0")
-        );
-      }
-      const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
-      const { field, direction } = this.parseOrderBy(orderBy);
+      const { resourceId, page = 0, perPage = 10 } = args;
       const table = await this.client.openTable(TABLE_THREADS);
-      const total = await table.countRows(`\`resourceId\` = '${this.escapeSql(resourceId)}'`);
-      const query = table.query().where(`\`resourceId\` = '${this.escapeSql(resourceId)}'`);
+      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) => {
-        const aValue = ["createdAt", "updatedAt"].includes(field) ? new Date(a[field]).getTime() : a[field];
-        const bValue = ["createdAt", "updatedAt"].includes(field) ? new Date(b[field]).getTime() : b[field];
-        if (aValue == null && bValue == null) return 0;
-        if (aValue == null) return direction === "ASC" ? -1 : 1;
-        if (bValue == null) return direction === "ASC" ? 1 : -1;
-        if (typeof aValue === "string" && typeof bValue === "string") {
-          return direction === "ASC" ? aValue.localeCompare(bValue) : bValue.localeCompare(aValue);
-        }
-        return direction === "ASC" ? aValue - bValue : bValue - aValue;
-      });
-      const paginatedRecords = records.slice(offset, offset + perPage);
+      records.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
       const schema = await getTableSchema({ tableName: TABLE_THREADS, client: this.client });
-      const threads = paginatedRecords.map(
-        (record) => processResultWithTypeConversion(record, schema)
-      );
+      const threads = records.map((record) => processResultWithTypeConversion(record, schema));
       return {
         threads,
         total,
         page,
-        perPage: perPageForResponse,
-        hasMore: offset + perPage < total
+        perPage,
+        hasMore: total > (page + 1) * perPage
       };
     } catch (error) {
       throw new MastraError(
         {
-          id: "LANCE_STORE_LIST_THREADS_BY_RESOURCE_ID_FAILED",
+          id: "LANCE_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY
         },
@@ -579,8 +616,132 @@ var StoreMemoryLance = class extends MemoryStorage {
     });
     return Array.from(allIndices).sort((a, b) => a - b).map((index) => records[index]);
   }
+  async getMessagesPaginated(args) {
+    const { threadId, resourceId, selectBy, format = "v1" } = args;
+    const page = selectBy?.pagination?.page ?? 0;
+    const perPage = selectBy?.pagination?.perPage ?? 10;
+    try {
+      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
+      const dateRange = selectBy?.pagination?.dateRange;
+      const fromDate = dateRange?.start;
+      const toDate = dateRange?.end;
+      const table = await this.client.openTable(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 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) {
+      const mastraError = new MastraError(
+        {
+          id: "LANCE_STORE_GET_MESSAGES_PAGINATED_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId,
+            resourceId: resourceId ?? ""
+          }
+        },
+        error
+      );
+      this.logger?.trackException?.(mastraError);
+      this.logger?.error?.(mastraError.toString());
+      return { messages: [], total: 0, page, perPage, hasMore: false };
+    }
+  }
   /**
-   * Parse message data from LanceDB record format to MastraDBMessage format
+   * Parse message data from LanceDB record format to MastraMessageV2 format
    */
   parseMessageData(data) {
     const { thread_id, ...rest } = data;
@@ -1290,7 +1451,8 @@ var StoreScoresLance = class extends ScoresStorage {
       const query = table.query().where(`id = '${id}'`).limit(1);
       const records = await query.toArray();
       if (records.length === 0) return null;
-      return await this.transformScoreRow(records[0]);
+      const schema = await getTableSchema({ tableName: TABLE_SCORERS, client: this.client });
+      return processResultWithTypeConversion(records[0], schema);
     } catch (error) {
       throw new MastraError(
         {
@@ -1304,17 +1466,7 @@ var StoreScoresLance = class extends ScoresStorage {
       );
     }
   }
-  async transformScoreRow(row) {
-    const schema = await getTableSchema({ tableName: TABLE_SCORERS, client: this.client });
-    const transformed = processResultWithTypeConversion(row, schema);
-    const result = {
-      ...transformed,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt
-    };
-    return result;
-  }
-  async listScoresByScorerId({
+  async getScoresByScorerId({
     scorerId,
     pagination,
     entityId,
@@ -1322,10 +1474,9 @@ var StoreScoresLance = class extends ScoresStorage {
     source
   }) {
     try {
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = normalizePerPage(perPageInput, 100);
-      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
       const table = await this.client.openTable(TABLE_SCORERS);
+      const { page = 0, perPage = 10 } = pagination || {};
+      const offset = page * perPage;
       let query = table.query().where(`\`scorerId\` = '${scorerId}'`);
       if (source) {
         query = query.where(`\`source\` = '${source}'`);
@@ -1336,31 +1487,23 @@ var StoreScoresLance = class extends ScoresStorage {
       if (entityType) {
         query = query.where(`\`entityType\` = '${entityType}'`);
       }
+      query = query.limit(perPage);
+      if (offset > 0) query.offset(offset);
+      const records = await query.toArray();
+      const schema = await getTableSchema({ tableName: TABLE_SCORERS, client: this.client });
+      const scores = processResultWithTypeConversion(records, schema);
       let totalQuery = table.query().where(`\`scorerId\` = '${scorerId}'`);
       if (source) {
         totalQuery = totalQuery.where(`\`source\` = '${source}'`);
       }
-      if (entityId) {
-        totalQuery = totalQuery.where(`\`entityId\` = '${entityId}'`);
-      }
-      if (entityType) {
-        totalQuery = totalQuery.where(`\`entityType\` = '${entityType}'`);
-      }
       const allRecords = await totalQuery.toArray();
       const total = allRecords.length;
-      const end = perPageInput === false ? total : start + perPage;
-      if (perPageInput !== false) {
-        query = query.limit(perPage);
-        if (start > 0) query = query.offset(start);
-      }
-      const records = await query.toArray();
-      const scores = await Promise.all(records.map(async (record) => await this.transformScoreRow(record)));
       return {
         pagination: {
           page,
-          perPage: perPageForResponse,
+          perPage,
           total,
-          hasMore: end < total
+          hasMore: offset + scores.length < total
         },
         scores
       };
@@ -1377,31 +1520,27 @@ var StoreScoresLance = class extends ScoresStorage {
       );
     }
   }
-  async listScoresByRunId({
+  async getScoresByRunId({
     runId,
     pagination
   }) {
     try {
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = normalizePerPage(perPageInput, 100);
-      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
       const table = await this.client.openTable(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: TABLE_SCORERS, client: this.client });
+      const scores = processResultWithTypeConversion(records, schema);
       const allRecords = await table.query().where(`\`runId\` = '${runId}'`).toArray();
       const total = allRecords.length;
-      const end = perPageInput === false ? total : start + perPage;
-      let query = table.query().where(`\`runId\` = '${runId}'`);
-      if (perPageInput !== false) {
-        query = query.limit(perPage);
-        if (start > 0) query = query.offset(start);
-      }
-      const records = await query.toArray();
-      const scores = await Promise.all(records.map(async (record) => await this.transformScoreRow(record)));
       return {
         pagination: {
           page,
-          perPage: perPageForResponse,
+          perPage,
           total,
-          hasMore: end < total
+          hasMore: offset + scores.length < total
         },
         scores
       };
@@ -1418,32 +1557,28 @@ var StoreScoresLance = class extends ScoresStorage {
       );
     }
   }
-  async listScoresByEntityId({
+  async getScoresByEntityId({
     entityId,
     entityType,
     pagination
   }) {
     try {
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = normalizePerPage(perPageInput, 100);
-      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
       const table = await this.client.openTable(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: 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;
-      const end = perPageInput === false ? total : start + perPage;
-      let query = table.query().where(`\`entityId\` = '${entityId}' AND \`entityType\` = '${entityType}'`);
-      if (perPageInput !== false) {
-        query = query.limit(perPage);
-        if (start > 0) query = query.offset(start);
-      }
-      const records = await query.toArray();
-      const scores = await Promise.all(records.map(async (record) => await this.transformScoreRow(record)));
       return {
         pagination: {
           page,
-          perPage: perPageForResponse,
+          perPage,
           total,
-          hasMore: end < total
+          hasMore: offset + scores.length < total
         },
         scores
       };
@@ -1460,32 +1595,28 @@ var StoreScoresLance = class extends ScoresStorage {
       );
     }
   }
-  async listScoresBySpan({
+  async getScoresBySpan({
     traceId,
     spanId,
     pagination
   }) {
     try {
-      const { page, perPage: perPageInput } = pagination;
-      const perPage = normalizePerPage(perPageInput, 100);
-      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
       const table = await this.client.openTable(TABLE_SCORERS);
+      const { page = 0, perPage = 10 } = pagination || {};
+      const offset = page * perPage;
+      const query = table.query().where(`\`traceId\` = '${traceId}' AND \`spanId\` = '${spanId}'`).limit(perPage);
+      if (offset > 0) query.offset(offset);
+      const records = await query.toArray();
+      const schema = await getTableSchema({ tableName: TABLE_SCORERS, client: this.client });
+      const scores = processResultWithTypeConversion(records, schema);
       const allRecords = await table.query().where(`\`traceId\` = '${traceId}' AND \`spanId\` = '${spanId}'`).toArray();
       const total = allRecords.length;
-      const end = perPageInput === false ? total : start + perPage;
-      let query = table.query().where(`\`traceId\` = '${traceId}' AND \`spanId\` = '${spanId}'`);
-      if (perPageInput !== false) {
-        query = query.limit(perPage);
-        if (start > 0) query = query.offset(start);
-      }
-      const records = await query.toArray();
-      const scores = await Promise.all(records.map(async (record) => await this.transformScoreRow(record)));
       return {
         pagination: {
           page,
-          perPage: perPageForResponse,
+          perPage,
           total,
-          hasMore: end < total
+          hasMore: offset + scores.length < total
         },
         scores
       };
@@ -1503,6 +1634,198 @@ var StoreScoresLance = class extends ScoresStorage {
     }
   }
 };
+var StoreTracesLance = class extends TracesStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  async saveTrace({ trace }) {
+    try {
+      const table = await this.client.openTable(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 MastraError(
+        {
+          id: "LANCE_STORE_SAVE_TRACE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
+  async getTraceById({ traceId }) {
+    try {
+      const table = await this.client.openTable(TABLE_TRACES);
+      const query = table.query().where(`id = '${traceId}'`);
+      const records = await query.toArray();
+      return records[0];
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "LANCE_STORE_GET_TRACE_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
+  async getTraces({
+    name,
+    scope,
+    page = 1,
+    perPage = 10,
+    attributes
+  }) {
+    try {
+      const table = await this.client.openTable(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) {
+      throw new MastraError(
+        {
+          id: "LANCE_STORE_GET_TRACES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { name: name ?? "", scope: scope ?? "" }
+        },
+        error
+      );
+    }
+  }
+  async getTracesPaginated(args) {
+    try {
+      const table = await this.client.openTable(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) {
+      throw new MastraError(
+        {
+          id: "LANCE_STORE_GET_TRACES_PAGINATED_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { name: args.name ?? "", scope: args.scope ?? "" }
+        },
+        error
+      );
+    }
+  }
+  async batchTraceInsert({ records }) {
+    this.logger.debug("Batch inserting traces", { count: records.length });
+    await this.operations.batchInsert({
+      tableName: TABLE_TRACES,
+      records
+    });
+  }
+};
 function parseWorkflowRun(row) {
   let parsedSnapshot = row.snapshot;
   if (typeof parsedSnapshot === "string") {
@@ -1532,7 +1855,7 @@ var StoreWorkflowsLance = class extends WorkflowsStorage {
     // runId,
     // stepId,
     // result,
-    // requestContext,
+    // runtimeContext,
   }) {
     throw new Error("Method not implemented.");
   }
@@ -1628,7 +1951,7 @@ var StoreWorkflowsLance = class extends WorkflowsStorage {
       );
     }
   }
-  async listWorkflowRuns(args) {
+  async getWorkflowRuns(args) {
     try {
       const table = await this.client.openTable(TABLE_WORKFLOW_SNAPSHOT);
       let query = table.query();
@@ -1656,22 +1979,11 @@ var StoreWorkflowsLance = class extends WorkflowsStorage {
       } else {
         total = await table.countRows();
       }
-      if (args?.perPage !== void 0 && args?.page !== void 0) {
-        const normalizedPerPage = normalizePerPage(args.perPage, Number.MAX_SAFE_INTEGER);
-        if (args.page < 0 || !Number.isInteger(args.page)) {
-          throw new MastraError(
-            {
-              id: "LANCE_STORE_INVALID_PAGINATION_PARAMS",
-              domain: ErrorDomain.STORAGE,
-              category: ErrorCategory.USER,
-              details: { page: args.page, perPage: args.perPage }
-            },
-            new Error(`Invalid pagination parameters: page=${args.page}, perPage=${args.perPage}`)
-          );
-        }
-        const offset = args.page * normalizedPerPage;
-        query.limit(normalizedPerPage);
-        query.offset(offset);
+      if (args?.limit) {
+        query.limit(args.limit);
+      }
+      if (args?.offset) {
+        query.offset(args.offset);
       }
       const records = await query.toArray();
       return {
@@ -1681,7 +1993,7 @@ var StoreWorkflowsLance = class extends WorkflowsStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "LANCE_STORE_LIST_WORKFLOW_RUNS_FAILED",
+          id: "LANCE_STORE_GET_WORKFLOW_RUNS_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { resourceId: args?.resourceId ?? "", workflowName: args?.workflowName ?? "" }
@@ -1698,8 +2010,6 @@ var LanceStorage = class _LanceStorage extends MastraStorage {
   lanceClient;
   /**
    * Creates a new instance of LanceStorage
-   * @param id The unique identifier for this storage instance
-   * @param name The name for this storage instance
    * @param uri The URI to connect to LanceDB
    * @param options connection options
    *
@@ -1707,29 +2017,31 @@ var LanceStorage = class _LanceStorage extends MastraStorage {
    *
    * Connect to a local database
    * ```ts
-   * const store = await LanceStorage.create('my-storage-id', 'MyStorage', '/path/to/db');
+   * const store = await LanceStorage.create('/path/to/db');
    * ```
    *
    * Connect to a LanceDB cloud database
    * ```ts
-   * const store = await LanceStorage.create('my-storage-id', 'MyStorage', 'db://host:port');
+   * const store = await LanceStorage.create('db://host:port');
    * ```
    *
    * Connect to a cloud database
    * ```ts
-   * const store = await LanceStorage.create('my-storage-id', 'MyStorage', 's3://bucket/db', { storageOptions: { timeout: '60s' } });
+   * const store = await LanceStorage.create('s3://bucket/db', { storageOptions: { timeout: '60s' } });
    * ```
    */
-  static async create(id, name, uri, options) {
-    const instance = new _LanceStorage(id, name);
+  static async create(name, uri, options) {
+    const instance = new _LanceStorage(name);
     try {
       instance.lanceClient = await 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 })
+        memory: new StoreMemoryLance({ client: instance.lanceClient, operations }),
+        legacyEvals: new StoreLegacyEvalsLance({ client: instance.lanceClient })
       };
       return instance;
     } catch (e) {
@@ -1749,13 +2061,15 @@ var LanceStorage = class _LanceStorage extends MastraStorage {
    * @internal
    * Private constructor to enforce using the create factory method
    */
-  constructor(id, name) {
-    super({ id, name });
+  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 })
     };
   }
@@ -1790,6 +2104,9 @@ var LanceStorage = class _LanceStorage extends MastraStorage {
   async getThreadById({ threadId }) {
     return this.stores.memory.getThreadById({ threadId });
   }
+  async getThreadsByResourceId({ resourceId }) {
+    return this.stores.memory.getThreadsByResourceId({ resourceId });
+  }
   /**
    * Saves a thread to the database. This function doesn't overwrite existing threads.
    * @param thread - The thread to save
@@ -1815,7 +2132,7 @@ var LanceStorage = class _LanceStorage extends MastraStorage {
       hasColumn: true,
       createTable: true,
       deleteMessages: false,
-      listScoresBySpan: true
+      getScoresBySpan: true
     };
   }
   async getResourceById({ resourceId }) {
@@ -1879,17 +2196,50 @@ var LanceStorage = class _LanceStorage extends MastraStorage {
     });
     return Array.from(allIndices).sort((a, b) => a - b).map((index) => records[index]);
   }
-  async listMessagesById({ messageIds }) {
-    return this.stores.memory.listMessagesById({ messageIds });
+  async getMessages({
+    threadId,
+    resourceId,
+    selectBy,
+    format,
+    threadConfig
+  }) {
+    return this.stores.memory.getMessages({ threadId, resourceId, selectBy, format, threadConfig });
+  }
+  async getMessagesById({
+    messageIds,
+    format
+  }) {
+    return this.stores.memory.getMessagesById({ messageIds, format });
   }
   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 listWorkflowRuns(args) {
-    return this.stores.workflows.listWorkflowRuns(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) {
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
+  }
+  async getEvals(options) {
+    return this.stores.legacyEvals.getEvals(options);
+  }
+  async getWorkflowRuns(args) {
+    return this.stores.workflows.getWorkflowRuns(args);
   }
   async getWorkflowRunById(args) {
     return this.stores.workflows.getWorkflowRunById(args);
@@ -1899,9 +2249,9 @@ var LanceStorage = class _LanceStorage extends MastraStorage {
     runId,
     stepId,
     result,
-    requestContext
+    runtimeContext
   }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
+    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, runtimeContext });
   }
   async updateWorkflowState({
     workflowName,
@@ -1927,37 +2277,37 @@ var LanceStorage = class _LanceStorage extends MastraStorage {
   async getScoreById({ id: _id }) {
     return this.stores.scores.getScoreById({ id: _id });
   }
-  async listScoresByScorerId({
+  async getScoresByScorerId({
     scorerId,
     source,
     entityId,
     entityType,
     pagination
   }) {
-    return this.stores.scores.listScoresByScorerId({ scorerId, source, pagination, entityId, entityType });
+    return this.stores.scores.getScoresByScorerId({ scorerId, source, pagination, entityId, entityType });
   }
   async saveScore(_score) {
     return this.stores.scores.saveScore(_score);
   }
-  async listScoresByRunId({
+  async getScoresByRunId({
     runId,
     pagination
   }) {
-    return this.stores.scores.listScoresByRunId({ runId, pagination });
+    return this.stores.scores.getScoresByRunId({ runId, pagination });
   }
-  async listScoresByEntityId({
+  async getScoresByEntityId({
     entityId,
     entityType,
     pagination
   }) {
-    return this.stores.scores.listScoresByEntityId({ entityId, entityType, pagination });
+    return this.stores.scores.getScoresByEntityId({ entityId, entityType, pagination });
   }
-  async listScoresBySpan({
+  async getScoresBySpan({
     traceId,
     spanId,
     pagination
   }) {
-    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
+    return this.stores.scores.getScoresBySpan({ traceId, spanId, pagination });
   }
 };
 var LanceFilterTranslator = class extends BaseFilterTranslator {
@@ -2306,7 +2656,7 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
    * ```
    */
   static async create(uri, options) {
-    const instance = new _LanceVectorStore(options?.id || crypto.randomUUID());
+    const instance = new _LanceVectorStore();
     try {
       instance.lanceClient = await connect(uri, options);
       return instance;
@@ -2326,8 +2676,8 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
    * @internal
    * Private constructor to enforce using the create factory method
    */
-  constructor(id) {
-    super({ id });
+  constructor() {
+    super();
   }
   close() {
     if (this.lanceClient) {