@mastra/lance 1.0.0-beta.7 → 1.0.0-beta.9

package/dist/index.js

@@ -1,7 +1,8 @@
 import { connect, Index } from '@lancedb/lancedb';
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
-import { MastraStorage, createStorageErrorId, createVectorErrorId, StoreOperations, MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, normalizePerPage, calculatePagination, TABLE_RESOURCES, ScoresStorage, TABLE_SCORERS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, ensureDate } from '@mastra/core/storage';
+import { MemoryStorage, TABLE_SCHEMAS, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, createStorageErrorId, normalizePerPage, calculatePagination, ScoresStorage, SCORERS_SCHEMA, TABLE_SCORERS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, MastraStorage, createVectorErrorId, getDefaultValue, ensureDate } from '@mastra/core/storage';
 import { MessageList } from '@mastra/core/agent';
+import { MastraBase } from '@mastra/core/base';
 import { Utf8, Float64, Binary, Float32, Int32, Field, Schema } from 'apache-arrow';
 import { saveScorePayloadSchema } from '@mastra/core/evals';
 import { MastraVector } from '@mastra/core/vector';
@@ -122,622 +123,503 @@ async function getTableSchema({
   }
 }
 
-// src/storage/domains/memory/index.ts
-var StoreMemoryLance = class extends MemoryStorage {
+// src/storage/db/index.ts
+function resolveLanceConfig(config) {
+  return config.client;
+}
+var LanceDB = class extends MastraBase {
   client;
-  operations;
-  constructor({ client, operations }) {
-    super();
+  constructor({ client }) {
+    super({ name: "lance-db" });
     this.client = client;
-    this.operations = operations;
   }
-  // Utility to escape single quotes in SQL strings
-  escapeSql(str) {
-    return str.replace(/'/g, "''");
+  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 getDefaultValue(type);
+    }
   }
-  async getThreadById({ threadId }) {
+  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 Utf8();
+          break;
+        case "int":
+        case "integer":
+          arrowType = new Int32();
+          break;
+        case "bigint":
+          arrowType = new Float64();
+          break;
+        case "float":
+          arrowType = new Float32();
+          break;
+        case "jsonb":
+        case "json":
+          arrowType = new Utf8();
+          break;
+        case "binary":
+          arrowType = new Binary();
+          break;
+        case "timestamp":
+          arrowType = new Float64();
+          break;
+        default:
+          arrowType = new Utf8();
+      }
+      return new Field(name, arrowType, column.nullable ?? true);
+    });
+    return new Schema(fields);
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
     try {
-      const thread = await this.operations.load({ tableName: TABLE_THREADS, keys: { id: threadId } });
-      if (!thread) {
-        return null;
+      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.");
       }
-      return {
-        ...thread,
-        createdAt: new Date(thread.createdAt),
-        updatedAt: new Date(thread.updatedAt)
-      };
     } catch (error) {
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "GET_THREAD_BY_ID", "FAILED"),
+          id: createStorageErrorId("LANCE", "CREATE_TABLE", "INVALID_ARGS"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
+          category: ErrorCategory.USER,
+          details: { tableName }
         },
         error
       );
     }
-  }
-  /**
-   * 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(TABLE_THREADS);
-      await table.add([record], { mode: "append" });
-      return thread;
+      const arrowSchema = this.translateSchema(schema);
+      await this.client.createEmptyTable(tableName, arrowSchema);
     } catch (error) {
+      if (error.message?.includes("already exists")) {
+        this.logger.debug(`Table '${tableName}' already exists, skipping create`);
+        return;
+      }
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "SAVE_THREAD", "FAILED"),
+          id: createStorageErrorId("LANCE", "CREATE_TABLE", "FAILED"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
         },
         error
       );
     }
   }
-  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(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) {
-        if (error.message?.includes("Commit conflict") && attempt < maxRetries - 1) {
-          const delay = Math.pow(2, attempt) * 10;
-          await new Promise((resolve) => setTimeout(resolve, delay));
-          continue;
-        }
-        throw new MastraError(
-          {
-            id: createStorageErrorId("LANCE", "UPDATE_THREAD", "FAILED"),
-            domain: ErrorDomain.STORAGE,
-            category: ErrorCategory.THIRD_PARTY
-          },
-          error
-        );
-      }
-    }
-    throw new MastraError(
-      {
-        id: createStorageErrorId("LANCE", "UPDATE_THREAD", "FAILED"),
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.THIRD_PARTY
-      },
-      new Error("All retries exhausted")
-    );
-  }
-  async deleteThread({ threadId }) {
+  async dropTable({ tableName }) {
     try {
-      const table = await this.client.openTable(TABLE_THREADS);
-      await table.delete(`id = '${threadId}'`);
-      const messagesTable = await this.client.openTable(TABLE_MESSAGES);
-      await messagesTable.delete(`thread_id = '${threadId}'`);
-    } catch (error) {
+      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 MastraError(
         {
-          id: createStorageErrorId("LANCE", "DELETE_THREAD", "FAILED"),
+          id: createStorageErrorId("LANCE", "DROP_TABLE", "INVALID_ARGS"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
+          category: ErrorCategory.USER,
+          text: validationError.message,
+          details: { tableName }
         },
-        error
+        validationError
       );
     }
-  }
-  normalizeMessage(message) {
-    const { thread_id, ...rest } = message;
-    return {
-      ...rest,
-      threadId: thread_id,
-      content: typeof message.content === "string" ? (() => {
-        try {
-          return JSON.parse(message.content);
-        } catch {
-          return message.content;
-        }
-      })() : message.content
-    };
-  }
-  async listMessagesById({ messageIds }) {
-    if (messageIds.length === 0) return { messages: [] };
     try {
-      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();
-      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() };
+      await this.client.dropTable(tableName);
     } catch (error) {
+      if (error.toString().includes("was not found") || error.message?.includes("Table not found")) {
+        this.logger.debug(`Table '${tableName}' does not exist, skipping drop`);
+        return;
+      }
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "LIST_MESSAGES_BY_ID", "FAILED"),
+          id: createStorageErrorId("LANCE", "DROP_TABLE", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: {
-            messageIds: JSON.stringify(messageIds)
-          }
+          details: { tableName }
         },
         error
       );
     }
   }
-  async listMessages(args) {
-    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
-    const threadIds = Array.isArray(threadId) ? threadId : [threadId];
-    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
+  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 MastraError(
         {
-          id: createStorageErrorId("LANCE", "LIST_MESSAGES", "INVALID_THREAD_ID"),
+          id: createStorageErrorId("LANCE", "ALTER_TABLE", "INVALID_ARGS"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { threadId: Array.isArray(threadId) ? threadId.join(",") : threadId }
+          category: ErrorCategory.USER,
+          text: validationError.message,
+          details: { tableName }
         },
-        new Error("threadId must be a non-empty string or array of non-empty strings")
+        validationError
       );
     }
-    const perPage = normalizePerPage(perPageInput, 40);
-    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
     try {
-      if (page < 0) {
-        throw new MastraError(
-          {
-            id: createStorageErrorId("LANCE", "LIST_MESSAGES", "INVALID_PAGE"),
-            domain: ErrorDomain.STORAGE,
-            category: ErrorCategory.USER,
-            details: { page }
-          },
-          new Error("page must be >= 0")
-        );
+      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}`);
       }
-      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
-      const table = await this.client.openTable(TABLE_MESSAGES);
-      const threadCondition = threadIds.length === 1 ? `thread_id = '${this.escapeSql(threadIds[0])}'` : `thread_id IN (${threadIds.map((t) => `'${this.escapeSql(t)}'`).join(", ")})`;
-      const conditions = [threadCondition];
-      if (resourceId) {
-        conditions.push(`\`resourceId\` = '${this.escapeSql(resourceId)}'`);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LANCE", "ALTER_TABLE", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  async clearTable({ tableName }) {
+    try {
+      if (!this.client) {
+        throw new Error("LanceDB client not initialized. Call LanceStorage.create() first.");
       }
-      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 (!tableName) {
+        throw new Error("tableName is required for clearTable.");
       }
-      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}`);
+    } catch (validationError) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LANCE", "CLEAR_TABLE", "INVALID_ARGS"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          text: validationError.message,
+          details: { tableName }
+        },
+        validationError
+      );
+    }
+    try {
+      const table = await this.client.openTable(tableName);
+      await table.delete("1=1");
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LANCE", "CLEAR_TABLE", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  async insert({ tableName, record }) {
+    try {
+      if (!this.client) {
+        throw new Error("LanceDB client not initialized. Call LanceStorage.create() first.");
       }
-      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
-        };
+      if (!tableName) {
+        throw new Error("tableName is required for insert.");
       }
-      const messageIds = new Set(messages.map((m) => m.id));
-      if (include && include.length > 0) {
-        const threadIds2 = [...new Set(include.map((item) => item.threadId || threadId))];
-        const allThreadMessages = [];
-        for (const tid of threadIds2) {
-          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);
-          }
-        }
+      if (!record || Object.keys(record).length === 0) {
+        throw new Error("record is required and cannot be empty for insert.");
       }
-      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);
+    } catch (validationError) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LANCE", "INSERT", "INVALID_ARGS"),
+          domain: ErrorDomain.STORAGE,
+          category: 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]);
         }
-        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
-      };
+      }
+      await table.mergeInsert(primaryId).whenMatchedUpdateAll().whenNotMatchedInsertAll().execute([processedRecord]);
     } catch (error) {
-      const mastraError = new MastraError(
+      throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "LIST_MESSAGES", "FAILED"),
+          id: createStorageErrorId("LANCE", "INSERT", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
-            resourceId: resourceId ?? ""
-          }
+          details: { tableName }
         },
         error
       );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException?.(mastraError);
-      return {
-        messages: [],
-        total: 0,
-        page,
-        perPage: perPageForResponse,
-        hasMore: false
-      };
     }
   }
-  async saveMessages(args) {
+  async batchInsert({ tableName, records }) {
     try {
-      const { messages } = args;
-      if (messages.length === 0) {
-        return { messages: [] };
+      if (!this.client) {
+        throw new Error("LanceDB client not initialized. Call LanceStorage.create() first.");
       }
-      const threadId = messages[0]?.threadId;
-      if (!threadId) {
-        throw new Error("Thread ID is required");
+      if (!tableName) {
+        throw new Error("tableName is required for batchInsert.");
       }
-      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");
-        }
+      if (!records || records.length === 0) {
+        throw new Error("records array is required and cannot be empty for batchInsert.");
       }
-      const transformedMessages = messages.map((message) => {
-        const { threadId: threadId2, type, ...rest } = message;
-        return {
-          ...rest,
-          thread_id: threadId2,
-          type: type ?? "v2",
-          content: JSON.stringify(message.content)
-        };
+    } catch (validationError) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LANCE", "BATCH_INSERT", "INVALID_ARGS"),
+          domain: ErrorDomain.STORAGE,
+          category: 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;
       });
-      const table = await this.client.openTable(TABLE_MESSAGES);
-      await table.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute(transformedMessages);
-      const threadsTable = await this.client.openTable(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 MessageList().add(messages, "memory");
-      return { messages: list.get.all.db() };
+      await table.mergeInsert(primaryId).whenMatchedUpdateAll().whenNotMatchedInsertAll().execute(processedRecords);
     } catch (error) {
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "SAVE_MESSAGES", "FAILED"),
+          id: createStorageErrorId("LANCE", "BATCH_INSERT", "FAILED"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
         },
         error
       );
     }
   }
-  async listThreadsByResourceId(args) {
+  async load({ tableName, keys }) {
     try {
-      const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
-      const perPage = normalizePerPage(perPageInput, 100);
-      if (page < 0) {
-        throw new MastraError(
-          {
-            id: createStorageErrorId("LANCE", "LIST_THREADS_BY_RESOURCE_ID", "INVALID_PAGE"),
-            domain: ErrorDomain.STORAGE,
-            category: ErrorCategory.USER,
-            details: { page }
-          },
-          new Error("page must be >= 0")
-        );
+      if (!this.client) {
+        throw new Error("LanceDB client not initialized. Call LanceStorage.create() first.");
       }
-      const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
-      const { field, direction } = this.parseOrderBy(orderBy);
-      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 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);
-      const schema = await getTableSchema({ tableName: TABLE_THREADS, client: this.client });
-      const threads = paginatedRecords.map(
-        (record) => processResultWithTypeConversion(record, schema)
+      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 MastraError(
+        {
+          id: createStorageErrorId("LANCE", "LOAD", "INVALID_ARGS"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          text: validationError.message,
+          details: { tableName }
+        },
+        validationError
       );
-      return {
-        threads,
-        total,
-        page,
-        perPage: perPageForResponse,
-        hasMore: offset + perPage < total
-      };
+    }
+    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) {
+      if (error instanceof MastraError) throw error;
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "LIST_THREADS_BY_RESOURCE_ID", "FAILED"),
+          id: createStorageErrorId("LANCE", "LOAD", "FAILED"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName, keyCount: Object.keys(keys).length, firstKey: Object.keys(keys)[0] ?? "" }
         },
         error
       );
     }
   }
-  /**
-   * 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);
+};
+
+// src/storage/domains/memory/index.ts
+var StoreMemoryLance = class extends MemoryStorage {
+  client;
+  #db;
+  constructor(config) {
+    super();
+    const client = resolveLanceConfig(config);
+    this.client = client;
+    this.#db = new LanceDB({ client });
+  }
+  async init() {
+    await this.#db.createTable({ tableName: TABLE_THREADS, schema: TABLE_SCHEMAS[TABLE_THREADS] });
+    await this.#db.createTable({ tableName: TABLE_MESSAGES, schema: TABLE_SCHEMAS[TABLE_MESSAGES] });
+    await this.#db.createTable({ tableName: TABLE_RESOURCES, schema: TABLE_SCHEMAS[TABLE_RESOURCES] });
+    await this.#db.alterTable({
+      tableName: TABLE_MESSAGES,
+      schema: TABLE_SCHEMAS[TABLE_MESSAGES],
+      ifNotExists: ["resourceId"]
     });
-    return Array.from(allIndices).sort((a, b) => a - b).map((index) => records[index]);
   }
-  /**
-   * Parse message data from LanceDB record format to MastraDBMessage 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 dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: TABLE_THREADS });
+    await this.#db.clearTable({ tableName: TABLE_MESSAGES });
+    await this.#db.clearTable({ tableName: TABLE_RESOURCES });
   }
-  async updateMessages(args) {
-    const { messages } = args;
-    this.logger.debug("Updating messages", { count: messages.length });
-    if (!messages.length) {
-      return [];
+  async deleteMessages(messageIds) {
+    if (!messageIds || messageIds.length === 0) {
+      return;
     }
-    const updatedMessages = [];
-    const affectedThreadIds = /* @__PURE__ */ new Set();
+    this.logger.debug("Deleting messages", { count: messageIds.length });
     try {
-      for (const updateData of messages) {
-        const { id, ...updates } = updateData;
-        const existingMessage = await this.operations.load({ tableName: 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: TABLE_MESSAGES, record: { id, ...updatePayload } });
-        const updatedMessage = await this.operations.load({ tableName: TABLE_MESSAGES, keys: { id } });
-        if (updatedMessage) {
-          updatedMessages.push(this.parseMessageData(updatedMessage));
+      const threadIds = /* @__PURE__ */ new Set();
+      for (const messageId of messageIds) {
+        const message = await this.#db.load({ tableName: TABLE_MESSAGES, keys: { id: messageId } });
+        if (message?.thread_id) {
+          threadIds.add(message.thread_id);
         }
       }
-      for (const threadId of affectedThreadIds) {
-        await this.operations.insert({
-          tableName: TABLE_THREADS,
-          record: { id: threadId, updatedAt: Date.now() }
-        });
+      const messagesTable = await this.client.openTable(TABLE_MESSAGES);
+      const idConditions = messageIds.map((id) => `id = '${this.escapeSql(id)}'`).join(" OR ");
+      await messagesTable.delete(idConditions);
+      const now = (/* @__PURE__ */ new Date()).getTime();
+      const threadsTable = await this.client.openTable(TABLE_THREADS);
+      for (const threadId of threadIds) {
+        const thread = await this.getThreadById({ threadId });
+        if (thread) {
+          const record = {
+            id: threadId,
+            resourceId: thread.resourceId,
+            title: thread.title,
+            metadata: JSON.stringify(thread.metadata),
+            createdAt: new Date(thread.createdAt).getTime(),
+            updatedAt: now
+          };
+          await threadsTable.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute([record]);
+        }
       }
-      return updatedMessages;
     } catch (error) {
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "UPDATE_MESSAGES", "FAILED"),
+          id: createStorageErrorId("LANCE", "DELETE_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { count: messages.length }
+          details: { count: messageIds.length }
         },
         error
       );
     }
   }
-  async getResourceById({ resourceId }) {
+  // Utility to escape single quotes in SQL strings
+  escapeSql(str) {
+    return str.replace(/'/g, "''");
+  }
+  async getThreadById({ threadId }) {
     try {
-      const resource = await this.operations.load({ tableName: TABLE_RESOURCES, keys: { id: resourceId } });
-      if (!resource) {
+      const thread = await this.#db.load({ tableName: TABLE_THREADS, keys: { id: threadId } });
+      if (!thread) {
         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
+        ...thread,
+        createdAt: new Date(thread.createdAt),
+        updatedAt: new Date(thread.updatedAt)
       };
     } catch (error) {
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "GET_RESOURCE_BY_ID", "FAILED"),
+          id: createStorageErrorId("LANCE", "GET_THREAD_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY
         },
@@ -745,23 +627,21 @@ var StoreMemoryLance = class extends MemoryStorage {
       );
     }
   }
-  async saveResource({ resource }) {
+  /**
+   * 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 = {
-        ...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(TABLE_RESOURCES);
+      const record = { ...thread, metadata: JSON.stringify(thread.metadata) };
+      const table = await this.client.openTable(TABLE_THREADS);
       await table.add([record], { mode: "append" });
-      return resource;
+      return thread;
     } catch (error) {
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "SAVE_RESOURCE", "FAILED"),
+          id: createStorageErrorId("LANCE", "SAVE_THREAD", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY
         },
@@ -769,44 +649,32 @@ var StoreMemoryLance = class extends MemoryStorage {
       );
     }
   }
-  async updateResource({
-    resourceId,
-    workingMemory,
+  async updateThread({
+    id,
+    title,
     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 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 updatedResource = {
-          ...existingResource,
-          workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
-          metadata: {
-            ...existingResource.metadata,
-            ...metadata
-          },
-          updatedAt: /* @__PURE__ */ new Date()
-        };
+        const mergedMetadata = { ...current.metadata, ...metadata };
         const record = {
-          id: resourceId,
-          workingMemory: updatedResource.workingMemory || "",
-          metadata: updatedResource.metadata ? JSON.stringify(updatedResource.metadata) : "",
-          updatedAt: updatedResource.updatedAt.getTime()
-          // Store as timestamp (milliseconds)
+          id,
+          title,
+          metadata: JSON.stringify(mergedMetadata),
+          updatedAt: (/* @__PURE__ */ new Date()).getTime()
         };
-        const table = await this.client.openTable(TABLE_RESOURCES);
+        const table = await this.client.openTable(TABLE_THREADS);
         await table.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute([record]);
-        return updatedResource;
+        const updatedThread = await this.getThreadById({ threadId: id });
+        if (!updatedThread) {
+          throw new Error(`Failed to retrieve updated thread ${id}`);
+        }
+        return updatedThread;
       } catch (error) {
         if (error.message?.includes("Commit conflict") && attempt < maxRetries - 1) {
           const delay = Math.pow(2, attempt) * 10;
@@ -815,7 +683,7 @@ var StoreMemoryLance = class extends MemoryStorage {
         }
         throw new MastraError(
           {
-            id: createStorageErrorId("LANCE", "UPDATE_RESOURCE", "FAILED"),
+            id: createStorageErrorId("LANCE", "UPDATE_THREAD", "FAILED"),
             domain: ErrorDomain.STORAGE,
             category: ErrorCategory.THIRD_PARTY
           },
@@ -823,418 +691,630 @@ var StoreMemoryLance = class extends MemoryStorage {
         );
       }
     }
-    throw new Error("Unexpected end of retry loop");
-  }
-};
-var StoreOperationsLance = class extends 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 Utf8();
-          break;
-        case "int":
-        case "integer":
-          arrowType = new Int32();
-          break;
-        case "bigint":
-          arrowType = new Float64();
-          break;
-        case "float":
-          arrowType = new Float32();
-          break;
-        case "jsonb":
-        case "json":
-          arrowType = new Utf8();
-          break;
-        case "binary":
-          arrowType = new Binary();
-          break;
-        case "timestamp":
-          arrowType = new Float64();
-          break;
-        default:
-          arrowType = new Utf8();
-      }
-      return new Field(name, arrowType, column.nullable ?? true);
-    });
-    return new Schema(fields);
+    throw new MastraError(
+      {
+        id: createStorageErrorId("LANCE", "UPDATE_THREAD", "FAILED"),
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.THIRD_PARTY
+      },
+      new Error("All retries exhausted")
+    );
   }
-  async createTable({
-    tableName,
-    schema
-  }) {
+  async deleteThread({ threadId }) {
     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.");
-      }
+      const table = await this.client.openTable(TABLE_THREADS);
+      await table.delete(`id = '${threadId}'`);
+      const messagesTable = await this.client.openTable(TABLE_MESSAGES);
+      await messagesTable.delete(`thread_id = '${threadId}'`);
     } catch (error) {
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "CREATE_TABLE", "INVALID_ARGS"),
+          id: createStorageErrorId("LANCE", "DELETE_THREAD", "FAILED"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.USER,
-          details: { tableName }
+          category: ErrorCategory.THIRD_PARTY
         },
         error
       );
     }
+  }
+  normalizeMessage(message) {
+    const { thread_id, ...rest } = message;
+    return {
+      ...rest,
+      threadId: thread_id,
+      content: typeof message.content === "string" ? (() => {
+        try {
+          return JSON.parse(message.content);
+        } catch {
+          return message.content;
+        }
+      })() : message.content
+    };
+  }
+  async listMessagesById({ messageIds }) {
+    if (messageIds.length === 0) return { messages: [] };
     try {
-      const arrowSchema = this.translateSchema(schema);
-      await this.client.createEmptyTable(tableName, arrowSchema);
+      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();
+      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() };
     } catch (error) {
-      if (error.message?.includes("already exists")) {
-        this.logger.debug(`Table '${tableName}' already exists, skipping create`);
-        return;
-      }
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "CREATE_TABLE", "FAILED"),
+          id: createStorageErrorId("LANCE", "LIST_MESSAGES_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
+          details: {
+            messageIds: JSON.stringify(messageIds)
+          }
         },
         error
       );
     }
   }
-  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) {
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    const threadIds = Array.isArray(threadId) ? threadId : [threadId];
+    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "DROP_TABLE", "INVALID_ARGS"),
+          id: createStorageErrorId("LANCE", "LIST_MESSAGES", "INVALID_THREAD_ID"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.USER,
-          text: validationError.message,
-          details: { tableName }
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: Array.isArray(threadId) ? threadId.join(",") : threadId }
         },
-        validationError
+        new Error("threadId must be a non-empty string or array of non-empty strings")
       );
     }
+    const perPage = normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
     try {
-      await this.client.dropTable(tableName);
-    } catch (error) {
-      if (error.toString().includes("was not found") || error.message?.includes("Table not found")) {
-        this.logger.debug(`Table '${tableName}' does not exist, skipping drop`);
-        return;
+      if (page < 0) {
+        throw new MastraError(
+          {
+            id: createStorageErrorId("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 threadCondition = threadIds.length === 1 ? `thread_id = '${this.escapeSql(threadIds[0])}'` : `thread_id IN (${threadIds.map((t) => `'${this.escapeSql(t)}'`).join(", ")})`;
+      const conditions = [threadCondition];
+      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 threadIds2 = [...new Set(include.map((item) => item.threadId || threadId))];
+        const allThreadMessages = [];
+        for (const tid of threadIds2) {
+          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);
+          }
+        }
       }
-      throw new MastraError(
+      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
+      };
+    } catch (error) {
+      const mastraError = new MastraError(
         {
-          id: createStorageErrorId("LANCE", "DROP_TABLE", "FAILED"),
+          id: createStorageErrorId("LANCE", "LIST_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
+          details: {
+            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
+            resourceId: resourceId ?? ""
+          }
         },
         error
       );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
     }
   }
-  async alterTable({
-    tableName,
-    schema,
-    ifNotExists
-  }) {
+  async saveMessages(args) {
     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.");
+      const { messages } = args;
+      if (messages.length === 0) {
+        return { messages: [] };
       }
-      if (!schema) {
-        throw new Error("schema is required for alterTable.");
+      const threadId = messages[0]?.threadId;
+      if (!threadId) {
+        throw new Error("Thread ID is required");
       }
-      if (!ifNotExists || ifNotExists.length === 0) {
-        this.logger.debug("No columns specified to add in alterTable, skipping.");
-        return;
+      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");
+        }
       }
-    } catch (validationError) {
-      throw new MastraError(
-        {
-          id: createStorageErrorId("LANCE", "ALTER_TABLE", "INVALID_ARGS"),
-          domain: ErrorDomain.STORAGE,
-          category: 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];
+      const transformedMessages = messages.map((message) => {
+        const { threadId: threadId2, type, ...rest } = message;
         return {
-          name: col,
-          valueSql: colDef?.nullable ? `cast(NULL as ${typeMap[colDef.type ?? "text"]})` : `cast(${this.getDefaultValue(colDef?.type ?? "text")} as ${typeMap[colDef?.type ?? "text"]})`
+          ...rest,
+          thread_id: threadId2,
+          type: type ?? "v2",
+          content: JSON.stringify(message.content)
         };
       });
-      if (columnsToAdd.length > 0) {
-        await table.addColumns(columnsToAdd);
-        this.logger?.info?.(`Added columns [${columnsToAdd.map((c) => c.name).join(", ")}] to table ${tableName}`);
-      }
+      const table = await this.client.openTable(TABLE_MESSAGES);
+      await table.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute(transformedMessages);
+      const threadsTable = await this.client.openTable(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 MessageList().add(messages, "memory");
+      return { messages: list.get.all.db() };
     } catch (error) {
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "ALTER_TABLE", "FAILED"),
+          id: createStorageErrorId("LANCE", "SAVE_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
+          category: ErrorCategory.THIRD_PARTY
         },
         error
       );
     }
   }
-  async clearTable({ tableName }) {
+  async listThreadsByResourceId(args) {
     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.");
+      const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
+      const perPage = normalizePerPage(perPageInput, 100);
+      if (page < 0) {
+        throw new MastraError(
+          {
+            id: createStorageErrorId("LANCE", "LIST_THREADS_BY_RESOURCE_ID", "INVALID_PAGE"),
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.USER,
+            details: { page }
+          },
+          new Error("page must be >= 0")
+        );
       }
-    } catch (validationError) {
-      throw new MastraError(
-        {
-          id: createStorageErrorId("LANCE", "CLEAR_TABLE", "INVALID_ARGS"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.USER,
-          text: validationError.message,
-          details: { tableName }
-        },
-        validationError
+      const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+      const { field, direction } = this.parseOrderBy(orderBy);
+      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 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);
+      const schema = await getTableSchema({ tableName: TABLE_THREADS, client: this.client });
+      const threads = paginatedRecords.map(
+        (record) => processResultWithTypeConversion(record, schema)
       );
-    }
-    try {
-      const table = await this.client.openTable(tableName);
-      await table.delete("1=1");
+      return {
+        threads,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: offset + perPage < total
+      };
     } catch (error) {
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "CLEAR_TABLE", "FAILED"),
+          id: createStorageErrorId("LANCE", "LIST_THREADS_BY_RESOURCE_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
+          category: ErrorCategory.THIRD_PARTY
         },
         error
       );
     }
   }
-  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.");
+  /**
+   * 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 (!record || Object.keys(record).length === 0) {
-        throw new Error("record is required and cannot be empty for insert.");
+    }
+    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);
       }
-    } catch (validationError) {
-      throw new MastraError(
-        {
-          id: createStorageErrorId("LANCE", "INSERT", "INVALID_ARGS"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.USER,
-          text: validationError.message,
-          details: { tableName }
-        },
-        validationError
-      );
+    });
+    additionalIndices.forEach((index) => {
+      allIndices.add(index);
+    });
+    return Array.from(allIndices).sort((a, b) => a - b).map((index) => records[index]);
+  }
+  /**
+   * Parse message data from LanceDB record format to MastraDBMessage 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 {
-      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]);
+      for (const updateData of messages) {
+        const { id, ...updates } = updateData;
+        const existingMessage = await this.#db.load({ tableName: 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.#db.insert({ tableName: TABLE_MESSAGES, record: { id, ...updatePayload } });
+        const updatedMessage = await this.#db.load({ tableName: TABLE_MESSAGES, keys: { id } });
+        if (updatedMessage) {
+          updatedMessages.push(this.parseMessageData(updatedMessage));
         }
       }
-      await table.mergeInsert(primaryId).whenMatchedUpdateAll().whenNotMatchedInsertAll().execute([processedRecord]);
+      for (const threadId of affectedThreadIds) {
+        await this.#db.insert({
+          tableName: TABLE_THREADS,
+          record: { id: threadId, updatedAt: Date.now() }
+        });
+      }
+      return updatedMessages;
     } catch (error) {
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "INSERT", "FAILED"),
+          id: createStorageErrorId("LANCE", "UPDATE_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
+          details: { count: messages.length }
         },
         error
       );
     }
   }
-  async batchInsert({ tableName, records }) {
+  async getResourceById({ resourceId }) {
     try {
-      if (!this.client) {
-        throw new Error("LanceDB client not initialized. Call LanceStorage.create() first.");
+      const resource = await this.#db.load({ tableName: TABLE_RESOURCES, keys: { id: resourceId } });
+      if (!resource) {
+        return null;
       }
-      if (!tableName) {
-        throw new Error("tableName is required for batchInsert.");
+      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();
       }
-      if (!records || records.length === 0) {
-        throw new Error("records array is required and cannot be empty for batchInsert.");
+      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();
       }
-    } catch (validationError) {
-      throw new MastraError(
-        {
-          id: createStorageErrorId("LANCE", "BATCH_INSERT", "INVALID_ARGS"),
-          domain: ErrorDomain.STORAGE,
-          category: 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]);
-          }
+      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 processedRecord;
-      });
-      await table.mergeInsert(primaryId).whenMatchedUpdateAll().whenNotMatchedInsertAll().execute(processedRecords);
+      }
+      return {
+        ...resource,
+        createdAt,
+        updatedAt,
+        workingMemory,
+        metadata
+      };
     } catch (error) {
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "BATCH_INSERT", "FAILED"),
+          id: createStorageErrorId("LANCE", "GET_RESOURCE_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
+          category: ErrorCategory.THIRD_PARTY
         },
         error
       );
     }
   }
-  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 MastraError(
-        {
-          id: createStorageErrorId("LANCE", "LOAD", "INVALID_ARGS"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.USER,
-          text: validationError.message,
-          details: { tableName }
-        },
-        validationError
-      );
-    }
+  async saveResource({ resource }) {
     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);
+      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(TABLE_RESOURCES);
+      await table.add([record], { mode: "append" });
+      return resource;
     } catch (error) {
-      if (error instanceof MastraError) throw error;
       throw new MastraError(
         {
-          id: createStorageErrorId("LANCE", "LOAD", "FAILED"),
+          id: createStorageErrorId("LANCE", "SAVE_RESOURCE", "FAILED"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName, keyCount: Object.keys(keys).length, firstKey: Object.keys(keys)[0] ?? "" }
+          category: ErrorCategory.THIRD_PARTY
         },
         error
       );
     }
   }
+  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(TABLE_RESOURCES);
+        await table.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute([record]);
+        return updatedResource;
+      } catch (error) {
+        if (error.message?.includes("Commit conflict") && attempt < maxRetries - 1) {
+          const delay = Math.pow(2, attempt) * 10;
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+        throw new MastraError(
+          {
+            id: createStorageErrorId("LANCE", "UPDATE_RESOURCE", "FAILED"),
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.THIRD_PARTY
+          },
+          error
+        );
+      }
+    }
+    throw new Error("Unexpected end of retry loop");
+  }
 };
 var StoreScoresLance = class extends ScoresStorage {
   client;
-  constructor({ client }) {
+  #db;
+  constructor(config) {
     super();
+    const client = resolveLanceConfig(config);
     this.client = client;
+    this.#db = new LanceDB({ client });
+  }
+  async init() {
+    await this.#db.createTable({ tableName: TABLE_SCORERS, schema: SCORERS_SCHEMA });
+    await this.#db.alterTable({
+      tableName: TABLE_SCORERS,
+      schema: SCORERS_SCHEMA,
+      ifNotExists: ["spanId", "requestContext"]
+    });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: TABLE_SCORERS });
   }
   async saveScore(score) {
     let validatedScore;
@@ -1248,7 +1328,7 @@ var StoreScoresLance = class extends ScoresStorage {
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.USER,
           details: {
-            scorer: score.scorer?.id ?? "unknown",
+            scorer: typeof score.scorer?.id === "string" ? score.scorer.id : String(score.scorer?.id ?? "unknown"),
             entityId: score.entityId ?? "unknown",
             entityType: score.entityType ?? "unknown",
             traceId: score.traceId ?? "",
@@ -1518,6 +1598,9 @@ var StoreScoresLance = class extends ScoresStorage {
     }
   }
 };
+function escapeSql(str) {
+  return str.replace(/'/g, "''");
+}
 function parseWorkflowRun(row) {
   let parsedSnapshot = row.snapshot;
   if (typeof parsedSnapshot === "string") {
@@ -1538,42 +1621,88 @@ function parseWorkflowRun(row) {
 }
 var StoreWorkflowsLance = class extends WorkflowsStorage {
   client;
-  constructor({ client }) {
+  #db;
+  constructor(config) {
     super();
+    const client = resolveLanceConfig(config);
     this.client = client;
+    this.#db = new LanceDB({ client });
+  }
+  async init() {
+    const schema = TABLE_SCHEMAS[TABLE_WORKFLOW_SNAPSHOT];
+    await this.#db.createTable({ tableName: TABLE_WORKFLOW_SNAPSHOT, schema });
+    await this.#db.alterTable({
+      tableName: TABLE_WORKFLOW_SNAPSHOT,
+      schema,
+      ifNotExists: ["resourceId"]
+    });
   }
-  updateWorkflowResults({
-    // workflowName,
-    // runId,
-    // stepId,
-    // result,
-    // requestContext,
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: TABLE_WORKFLOW_SNAPSHOT });
+  }
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    requestContext
   }) {
-    throw new Error("Method not implemented.");
+    let snapshot = await this.loadWorkflowSnapshot({ workflowName, runId });
+    if (!snapshot) {
+      snapshot = {
+        context: {},
+        activePaths: [],
+        timestamp: Date.now(),
+        suspendedPaths: {},
+        activeStepsPath: {},
+        resumeLabels: {},
+        serializedStepGraph: [],
+        status: "pending",
+        value: {},
+        waitingPaths: {},
+        runId,
+        requestContext: {}
+      };
+    }
+    snapshot.context[stepId] = result;
+    snapshot.requestContext = { ...snapshot.requestContext, ...requestContext };
+    await this.persistWorkflowSnapshot({ workflowName, runId, snapshot });
+    return snapshot.context;
   }
-  updateWorkflowState({
-    // workflowName,
-    // runId,
-    // opts,
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
   }) {
-    throw new Error("Method not implemented.");
+    const snapshot = await this.loadWorkflowSnapshot({ workflowName, runId });
+    if (!snapshot) {
+      return void 0;
+    }
+    if (!snapshot.context) {
+      throw new Error(`Snapshot not found for runId ${runId}`);
+    }
+    const updatedSnapshot = { ...snapshot, ...opts };
+    await this.persistWorkflowSnapshot({ workflowName, runId, snapshot: updatedSnapshot });
+    return updatedSnapshot;
   }
   async persistWorkflowSnapshot({
     workflowName,
     runId,
     resourceId,
-    snapshot
+    snapshot,
+    createdAt,
+    updatedAt
   }) {
     try {
       const table = await this.client.openTable(TABLE_WORKFLOW_SNAPSHOT);
-      const query = table.query().where(`workflow_name = '${workflowName}' AND run_id = '${runId}'`);
+      const query = table.query().where(`workflow_name = '${escapeSql(workflowName)}' AND run_id = '${escapeSql(runId)}'`);
       const records = await query.toArray();
-      let createdAt;
-      const now = Date.now();
+      let createdAtValue;
+      const now = createdAt?.getTime() ?? Date.now();
       if (records.length > 0) {
-        createdAt = records[0].createdAt ?? now;
+        createdAtValue = records[0].createdAt ?? now;
       } else {
-        createdAt = now;
+        createdAtValue = now;
       }
       const { status, value, ...rest } = snapshot;
       const record = {
@@ -1582,8 +1711,8 @@ var StoreWorkflowsLance = class extends WorkflowsStorage {
         resourceId,
         snapshot: JSON.stringify({ status, value, ...rest }),
         // this is to ensure status is always just before value, for when querying the db by status
-        createdAt,
-        updatedAt: now
+        createdAt: createdAtValue,
+        updatedAt: updatedAt ?? now
       };
       await table.mergeInsert(["workflow_name", "run_id"]).whenMatchedUpdateAll().whenNotMatchedInsertAll().execute([record]);
     } catch (error) {
@@ -1604,7 +1733,7 @@ var StoreWorkflowsLance = class extends WorkflowsStorage {
   }) {
     try {
       const table = await this.client.openTable(TABLE_WORKFLOW_SNAPSHOT);
-      const query = table.query().where(`workflow_name = '${workflowName}' AND run_id = '${runId}'`);
+      const query = table.query().where(`workflow_name = '${escapeSql(workflowName)}' AND run_id = '${escapeSql(runId)}'`);
       const records = await query.toArray();
       return records.length > 0 ? JSON.parse(records[0].snapshot) : null;
     } catch (error) {
@@ -1622,9 +1751,9 @@ var StoreWorkflowsLance = class extends WorkflowsStorage {
   async getWorkflowRunById(args) {
     try {
       const table = await this.client.openTable(TABLE_WORKFLOW_SNAPSHOT);
-      let whereClause = `run_id = '${args.runId}'`;
+      let whereClause = `run_id = '${escapeSql(args.runId)}'`;
       if (args.workflowName) {
-        whereClause += ` AND workflow_name = '${args.workflowName}'`;
+        whereClause += ` AND workflow_name = '${escapeSql(args.workflowName)}'`;
       }
       const query = table.query().where(whereClause);
       const records = await query.toArray();
@@ -1646,7 +1775,7 @@ var StoreWorkflowsLance = class extends WorkflowsStorage {
   async deleteWorkflowRunById({ runId, workflowName }) {
     try {
       const table = await this.client.openTable(TABLE_WORKFLOW_SNAPSHOT);
-      const whereClause = `run_id = '${runId.replace(/'/g, "''")}' AND workflow_name = '${workflowName.replace(/'/g, "''")}'`;
+      const whereClause = `run_id = '${escapeSql(runId)}' AND workflow_name = '${escapeSql(workflowName)}'`;
       await table.delete(whereClause);
     } catch (error) {
       throw new MastraError(
@@ -1666,14 +1795,14 @@ var StoreWorkflowsLance = class extends WorkflowsStorage {
       let query = table.query();
       const conditions = [];
       if (args?.workflowName) {
-        conditions.push(`workflow_name = '${args.workflowName.replace(/'/g, "''")}'`);
+        conditions.push(`workflow_name = '${escapeSql(args.workflowName)}'`);
       }
       if (args?.status) {
         const escapedStatus = args.status.replace(/\\/g, "\\\\").replace(/'/g, "''").replace(/%/g, "\\%").replace(/_/g, "\\_");
         conditions.push(`\`snapshot\` LIKE '%"status":"${escapedStatus}","value"%'`);
       }
       if (args?.resourceId) {
-        conditions.push(`\`resourceId\` = '${args.resourceId}'`);
+        conditions.push(`\`resourceId\` = '${escapeSql(args.resourceId)}'`);
       }
       if (args?.fromDate instanceof Date) {
         conditions.push(`\`createdAt\` >= ${args.fromDate.getTime()}`);
@@ -1762,12 +1891,10 @@ var LanceStorage = class _LanceStorage extends MastraStorage {
     const instance = new _LanceStorage(id, name, storageOptions?.disableInit);
     try {
       instance.lanceClient = await connect(uri, connectionOptions);
-      const operations = new StoreOperationsLance({ client: instance.lanceClient });
       instance.stores = {
-        operations: new StoreOperationsLance({ client: instance.lanceClient }),
         workflows: new StoreWorkflowsLance({ client: instance.lanceClient }),
         scores: new StoreScoresLance({ client: instance.lanceClient }),
-        memory: new StoreMemoryLance({ client: instance.lanceClient, operations })
+        memory: new StoreMemoryLance({ client: instance.lanceClient })
       };
       return instance;
     } catch (e) {
@@ -1784,221 +1911,43 @@ var LanceStorage = class _LanceStorage extends MastraStorage {
     }
   }
   /**
-   * @internal
-   * Private constructor to enforce using the create factory method
-   */
-  constructor(id, name, disableInit) {
-    super({ id, name, disableInit });
-    const operations = new StoreOperationsLance({ client: this.lanceClient });
-    this.stores = {
-      operations: new StoreOperationsLance({ client: this.lanceClient }),
-      workflows: new StoreWorkflowsLance({ client: this.lanceClient }),
-      scores: new StoreScoresLance({ client: this.lanceClient }),
-      memory: new StoreMemoryLance({ client: this.lanceClient, operations })
-    };
-  }
-  async createTable({
-    tableName,
-    schema
-  }) {
-    return this.stores.operations.createTable({ tableName, schema });
-  }
-  async dropTable({ tableName }) {
-    return this.stores.operations.dropTable({ tableName });
-  }
-  async alterTable({
-    tableName,
-    schema,
-    ifNotExists
-  }) {
-    return this.stores.operations.alterTable({ tableName, schema, ifNotExists });
-  }
-  async clearTable({ tableName }) {
-    return this.stores.operations.clearTable({ tableName });
-  }
-  async insert({ tableName, record }) {
-    return this.stores.operations.insert({ tableName, record });
-  }
-  async batchInsert({ tableName, records }) {
-    return this.stores.operations.batchInsert({ tableName, records });
-  }
-  async load({ tableName, keys }) {
-    return this.stores.operations.load({ tableName, keys });
-  }
-  async getThreadById({ threadId }) {
-    return this.stores.memory.getThreadById({ threadId });
-  }
-  /**
-   * Saves a thread to the database. This function doesn't overwrite existing threads.
-   * @param thread - The thread to save
-   * @returns The saved thread
+   * Creates a new instance of LanceStorage from a pre-configured LanceDB connection.
+   * Use this when you need to configure the connection before initialization.
+   *
+   * @param id The unique identifier for this storage instance
+   * @param name The name for this storage instance
+   * @param client Pre-configured LanceDB connection
+   * @param options Storage options including disableInit
+   *
+   * @example
+   * ```typescript
+   * import { connect } from '@lancedb/lancedb';
+   *
+   * const client = await connect('/path/to/db', {
+   *   // Custom connection options
+   * });
+   *
+   * const store = LanceStorage.fromClient('my-id', 'MyStorage', client);
+   * ```
    */
-  async saveThread({ thread }) {
-    return this.stores.memory.saveThread({ thread });
-  }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    return this.stores.memory.updateThread({ id, title, metadata });
-  }
-  async deleteThread({ threadId }) {
-    return this.stores.memory.deleteThread({ threadId });
-  }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true,
-      hasColumn: true,
-      createTable: true,
-      deleteMessages: false,
-      listScoresBySpan: true
+  static fromClient(id, name, client, options) {
+    const instance = new _LanceStorage(id, name, options?.disableInit);
+    instance.lanceClient = client;
+    instance.stores = {
+      workflows: new StoreWorkflowsLance({ client }),
+      scores: new StoreScoresLance({ client }),
+      memory: new StoreMemoryLance({ client })
     };
-  }
-  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 });
+    return instance;
   }
   /**
-   * 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
+   * @internal
+   * Private constructor to enforce using the create factory method.
+   * Note: stores is initialized in create() after the lanceClient is connected.
    */
-  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 listMessagesById({ messageIds }) {
-    return this.stores.memory.listMessagesById({ messageIds });
-  }
-  async saveMessages(args) {
-    return this.stores.memory.saveMessages(args);
-  }
-  async updateMessages(_args) {
-    return this.stores.memory.updateMessages(_args);
-  }
-  async listWorkflowRuns(args) {
-    return this.stores.workflows.listWorkflowRuns(args);
-  }
-  async getWorkflowRunById(args) {
-    return this.stores.workflows.getWorkflowRunById(args);
-  }
-  async deleteWorkflowRunById({ runId, workflowName }) {
-    return this.stores.workflows.deleteWorkflowRunById({ runId, workflowName });
-  }
-  async updateWorkflowResults({
-    workflowName,
-    runId,
-    stepId,
-    result,
-    requestContext
-  }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
-  }
-  async updateWorkflowState({
-    workflowName,
-    runId,
-    opts
-  }) {
-    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
-  }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    resourceId,
-    snapshot
-  }) {
-    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot });
-  }
-  async loadWorkflowSnapshot({
-    workflowName,
-    runId
-  }) {
-    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
-  }
-  async getScoreById({ id: _id }) {
-    return this.stores.scores.getScoreById({ id: _id });
-  }
-  async listScoresByScorerId({
-    scorerId,
-    source,
-    entityId,
-    entityType,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByScorerId({ scorerId, source, pagination, entityId, entityType });
-  }
-  async saveScore(score) {
-    return this.stores.scores.saveScore(score);
-  }
-  async listScoresByRunId({
-    runId,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByRunId({ runId, pagination });
-  }
-  async listScoresByEntityId({
-    entityId,
-    entityType,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByEntityId({ entityId, entityType, pagination });
-  }
-  async listScoresBySpan({
-    traceId,
-    spanId,
-    pagination
-  }) {
-    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
+  constructor(id, name, disableInit) {
+    super({ id, name, disableInit });
+    this.stores = {};
   }
 };
 var LanceFilterTranslator = class extends BaseFilterTranslator {
@@ -3221,6 +3170,6 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
   }
 };
 
-export { LanceStorage, LanceVectorStore };
+export { LanceStorage, LanceVectorStore, StoreMemoryLance, StoreScoresLance, StoreWorkflowsLance };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map