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

package/src/storage/index.ts

@@ -1,34 +1,34 @@
 import { connect } from '@lancedb/lancedb';
-import type { Connection, ConnectionOptions, SchemaLike, FieldLike } from '@lancedb/lancedb';
+import type { Connection, ConnectionOptions } from '@lancedb/lancedb';
 import type { MastraMessageContentV2 } from '@mastra/core/agent';
-import { MessageList } from '@mastra/core/agent';
+import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
 import type { MastraMessageV1, MastraMessageV2, StorageThreadType, TraceType } from '@mastra/core/memory';
-import {
-  MastraStorage,
-  TABLE_EVALS,
-  TABLE_MESSAGES,
-  TABLE_THREADS,
-  TABLE_TRACES,
-  TABLE_WORKFLOW_SNAPSHOT,
-} from '@mastra/core/storage';
+import type { ScoreRowData } from '@mastra/core/scores';
+import { MastraStorage } from '@mastra/core/storage';
 import type {
   TABLE_NAMES,
   PaginationInfo,
   StorageGetMessagesArg,
-  StorageGetTracesArg,
   StorageColumn,
   EvalRow,
-  WorkflowRun,
   WorkflowRuns,
+  StoragePagination,
+  StorageDomains,
+  StorageGetTracesPaginatedArg,
+  StorageResourceType,
 } from '@mastra/core/storage';
 import type { Trace } from '@mastra/core/telemetry';
 import type { WorkflowRunState } from '@mastra/core/workflows';
-import type { DataType } from 'apache-arrow';
-import { Utf8, Int32, Float32, Binary, Schema, Field, Float64 } from 'apache-arrow';
+import { StoreLegacyEvalsLance } from './domains/legacy-evals';
+import { StoreMemoryLance } from './domains/memory';
+import { StoreOperationsLance } from './domains/operations';
+import { StoreScoresLance } from './domains/scores';
+import { StoreTracesLance } from './domains/traces';
+import { StoreWorkflowsLance } from './domains/workflows';
 
 export class LanceStorage extends MastraStorage {
+  stores: StorageDomains;
   private lanceClient!: Connection;
-
   /**
    * Creates a new instance of LanceStorage
    * @param uri The URI to connect to LanceDB
@@ -55,9 +55,27 @@ export class LanceStorage extends MastraStorage {
     const instance = new LanceStorage(name);
     try {
       instance.lanceClient = await connect(uri, options);
+      const operations = new StoreOperationsLance({ client: instance.lanceClient });
+      instance.stores = {
+        operations: new StoreOperationsLance({ client: instance.lanceClient }),
+        workflows: new StoreWorkflowsLance({ client: instance.lanceClient }),
+        traces: new StoreTracesLance({ client: instance.lanceClient, operations }),
+        scores: new StoreScoresLance({ client: instance.lanceClient }),
+        memory: new StoreMemoryLance({ client: instance.lanceClient, operations }),
+        legacyEvals: new StoreLegacyEvalsLance({ client: instance.lanceClient }),
+      };
       return instance;
     } catch (e: any) {
-      throw new Error(`Failed to connect to LanceDB: ${e}`);
+      throw new MastraError(
+        {
+          id: 'STORAGE_LANCE_STORAGE_CONNECT_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to connect to LanceDB: ${e.message || e}`,
+          details: { uri, optionsProvided: !!options },
+        },
+        e,
+      );
     }
   }
 
@@ -67,6 +85,16 @@ export class LanceStorage extends MastraStorage {
    */
   private constructor(name: string) {
     super({ name });
+    const operations = new StoreOperationsLance({ client: this.lanceClient });
+
+    this.stores = {
+      operations: new StoreOperationsLance({ client: this.lanceClient }),
+      workflows: new StoreWorkflowsLance({ client: this.lanceClient }),
+      traces: new StoreTracesLance({ client: this.lanceClient, operations }),
+      scores: new StoreScoresLance({ client: this.lanceClient }),
+      legacyEvals: new StoreLegacyEvalsLance({ client: this.lanceClient }),
+      memory: new StoreMemoryLance({ client: this.lanceClient, operations }),
+    };
   }
 
   async createTable({
@@ -76,405 +104,47 @@ export class LanceStorage extends MastraStorage {
     tableName: TABLE_NAMES;
     schema: Record<string, StorageColumn>;
   }): Promise<void> {
-    try {
-      const arrowSchema = this.translateSchema(schema);
-      await this.lanceClient.createEmptyTable(tableName, arrowSchema);
-    } catch (error: any) {
-      throw new Error(`Failed to create table: ${error}`);
-    }
-  }
-
-  private translateSchema(schema: Record<string, StorageColumn>): Schema {
-    const fields = Object.entries(schema).map(([name, column]) => {
-      // Convert string type to Arrow DataType
-      let arrowType: DataType;
-      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:
-          // Default to string for unknown types
-          arrowType = new Utf8();
-      }
-
-      // Create a field with the appropriate arrow type
-      return new Field(name, arrowType, column.nullable ?? true);
-    });
-
-    return new Schema(fields);
-  }
-
-  /**
-   * Drop a table if it exists
-   * @param tableName Name of the table to drop
-   */
-  async dropTable(tableName: TABLE_NAMES): Promise<void> {
-    try {
-      await this.lanceClient.dropTable(tableName);
-    } catch (error: any) {
-      // Don't throw if the table doesn't exist
-      if (error.toString().includes('was not found')) {
-        this.logger.debug(`Table '${tableName}' does not exist, skipping drop`);
-        return;
-      }
-      throw new Error(`Failed to drop table: ${error}`);
-    }
-  }
-
-  /**
-   * Get table schema
-   * @param tableName Name of the table
-   * @returns Table schema
-   */
-  async getTableSchema(tableName: TABLE_NAMES): Promise<SchemaLike> {
-    try {
-      const table = await this.lanceClient.openTable(tableName);
-      const rawSchema = await table.schema();
-      const fields = rawSchema.fields as FieldLike[];
-
-      // Convert schema to SchemaLike format
-      return {
-        fields,
-        metadata: new Map<string, string>(),
-        get names() {
-          return fields.map((field: FieldLike) => field.name);
-        },
-      };
-    } catch (error: any) {
-      throw new Error(`Failed to get table schema: ${error}`);
-    }
+    return this.stores.operations.createTable({ tableName, schema });
   }
 
-  protected getDefaultValue(type: StorageColumn['type']): string {
-    switch (type) {
-      case 'text':
-        return "''";
-      case 'timestamp':
-        return 'CURRENT_TIMESTAMP';
-      case 'integer':
-      case 'bigint':
-        return '0';
-      case 'jsonb':
-        return "'{}'";
-      case 'uuid':
-        return "''";
-      default:
-        return super.getDefaultValue(type);
-    }
+  async dropTable({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
+    return this.stores.operations.dropTable({ tableName });
   }
 
-  /**
-   * Alters table schema to add columns if they don't exist
-   * @param tableName Name of the table
-   * @param schema Schema of the table
-   * @param ifNotExists Array of column names to add if they don't exist
-   */
   async alterTable({
     tableName,
     schema,
     ifNotExists,
   }: {
-    tableName: string;
+    tableName: TABLE_NAMES;
     schema: Record<string, StorageColumn>;
     ifNotExists: string[];
   }): Promise<void> {
-    const table = await this.lanceClient.openTable(tableName);
-    const currentSchema = await table.schema();
-    const existingFields = new Set(currentSchema.fields.map((f: any) => f.name));
-
-    const typeMap: Record<string, string> = {
-      text: 'string',
-      integer: 'int',
-      bigint: 'bigint',
-      timestamp: 'timestamp',
-      jsonb: 'string',
-      uuid: 'string',
-    };
-
-    // Find columns to add
-    const columnsToAdd = ifNotExists
-      .filter(col => schema[col] && !existingFields.has(col))
-      .map(col => {
-        const colDef = schema[col];
-        return {
-          name: col,
-          valueSql: colDef?.nullable
-            ? `cast(NULL as ${typeMap[colDef.type ?? 'text']})`
-            : `cast(${this.getDefaultValue(colDef?.type ?? 'text')} as ${typeMap[colDef?.type ?? 'text']})`,
-        };
-      });
-
-    if (columnsToAdd.length > 0) {
-      await table.addColumns(columnsToAdd);
-      this.logger?.info?.(`Added columns [${columnsToAdd.map(c => c.name).join(', ')}] to table ${tableName}`);
-    }
+    return this.stores.operations.alterTable({ tableName, schema, ifNotExists });
   }
 
   async clearTable({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
-    const table = await this.lanceClient.openTable(tableName);
-
-    // delete function always takes a predicate as an argument, so we use '1=1' to delete all records because it is always true.
-    await table.delete('1=1');
+    return this.stores.operations.clearTable({ tableName });
   }
 
-  /**
-   * Insert a single record into a table. This function overwrites the existing record if it exists. Use this function for inserting records into tables with custom schemas.
-   * @param tableName The name of the table to insert into.
-   * @param record The record to insert.
-   */
-  async insert({ tableName, record }: { tableName: string; record: Record<string, any> }): Promise<void> {
-    try {
-      const table = await this.lanceClient.openTable(tableName);
-
-      const processedRecord = { ...record };
-
-      for (const key in processedRecord) {
-        if (
-          processedRecord[key] !== null &&
-          typeof processedRecord[key] === 'object' &&
-          !(processedRecord[key] instanceof Date)
-        ) {
-          this.logger.debug('Converting object to JSON string: ', processedRecord[key]);
-          processedRecord[key] = JSON.stringify(processedRecord[key]);
-        }
-      }
-
-      await table.add([processedRecord], { mode: 'overwrite' });
-    } catch (error: any) {
-      throw new Error(`Failed to insert record: ${error}`);
-    }
+  async insert({ tableName, record }: { tableName: TABLE_NAMES; record: Record<string, any> }): Promise<void> {
+    return this.stores.operations.insert({ tableName, record });
   }
 
-  /**
-   * Insert multiple records into a table. This function overwrites the existing records if they exist. Use this function for inserting records into tables with custom schemas.
-   * @param tableName The name of the table to insert into.
-   * @param records The records to insert.
-   */
-  async batchInsert({ tableName, records }: { tableName: string; records: Record<string, any>[] }): Promise<void> {
-    try {
-      const table = await this.lanceClient.openTable(tableName);
-
-      const processedRecords = records.map(record => {
-        const processedRecord = { ...record };
-
-        // Convert values based on schema type
-        for (const key in processedRecord) {
-          // Skip null/undefined values
-          if (processedRecord[key] == null) continue;
-
-          if (
-            processedRecord[key] !== null &&
-            typeof processedRecord[key] === 'object' &&
-            !(processedRecord[key] instanceof Date)
-          ) {
-            processedRecord[key] = JSON.stringify(processedRecord[key]);
-          }
-        }
-
-        return processedRecord;
-      });
-
-      await table.add(processedRecords, { mode: 'overwrite' });
-    } catch (error: any) {
-      throw new Error(`Failed to batch insert records: ${error}`);
-    }
+  async batchInsert({ tableName, records }: { tableName: TABLE_NAMES; records: Record<string, any>[] }): Promise<void> {
+    return this.stores.operations.batchInsert({ tableName, records });
   }
 
-  /**
-   * Load a record from the database by its key(s)
-   * @param tableName The name of the table to query
-   * @param keys Record of key-value pairs to use for lookup
-   * @throws Error if invalid types are provided for keys
-   * @returns The loaded record with proper type conversions, or null if not found
-   */
   async load({ tableName, keys }: { tableName: TABLE_NAMES; keys: Record<string, any> }): Promise<any> {
-    try {
-      const table = await this.lanceClient.openTable(tableName);
-      const tableSchema = await this.getTableSchema(tableName);
-      const query = table.query();
-
-      // Build filter condition with 'and' between all conditions
-      if (Object.keys(keys).length > 0) {
-        // Validate key types against schema
-        this.validateKeyTypes(keys, tableSchema);
-
-        const filterConditions = Object.entries(keys)
-          .map(([key, value]) => {
-            // Check if key is in camelCase and wrap it in backticks if it is
-            const isCamelCase = /^[a-z][a-zA-Z]*$/.test(key) && /[A-Z]/.test(key);
-            const quotedKey = isCamelCase ? `\`${key}\`` : key;
-
-            // Handle different types appropriately
-            if (typeof value === 'string') {
-              return `${quotedKey} = '${value}'`;
-            } else if (value === null) {
-              return `${quotedKey} IS NULL`;
-            } else {
-              // For numbers, booleans, etc.
-              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;
-      }
-
-      // Process the result with type conversions
-      return this.processResultWithTypeConversion(result[0], tableSchema);
-    } catch (error: any) {
-      throw new Error(`Failed to load record: ${error}`);
-    }
+    return this.stores.operations.load({ tableName, keys });
   }
 
-  /**
-   * Validates that key types match the schema definition
-   * @param keys The keys to validate
-   * @param tableSchema The table schema to validate against
-   * @throws Error if a key has an incompatible type
-   */
-  private validateKeyTypes(keys: Record<string, any>, tableSchema: SchemaLike): void {
-    // Create a map of field names to their expected types
-    const fieldTypes = new Map(
-      tableSchema.fields.map((field: any) => [field.name, field.type?.toString().toLowerCase()]),
-    );
-
-    for (const [key, value] of Object.entries(keys)) {
-      const fieldType = fieldTypes.get(key);
-
-      if (!fieldType) {
-        throw new Error(`Field '${key}' does not exist in table schema`);
-      }
-
-      // Type validation
-      if (value !== null) {
-        if ((fieldType.includes('int') || fieldType.includes('bigint')) && typeof value !== 'number') {
-          throw new Error(`Expected numeric value for field '${key}', got ${typeof value}`);
-        }
-
-        if (fieldType.includes('utf8') && typeof value !== 'string') {
-          throw new Error(`Expected string value for field '${key}', got ${typeof value}`);
-        }
-
-        if (fieldType.includes('timestamp') && !(value instanceof Date) && typeof value !== 'string') {
-          throw new Error(`Expected Date or string value for field '${key}', got ${typeof value}`);
-        }
-      }
-    }
-  }
-
-  /**
-   * Process a database result with appropriate type conversions based on the table schema
-   * @param rawResult The raw result object from the database
-   * @param tableSchema The schema of the table containing type information
-   * @returns Processed result with correct data types
-   */
-  private processResultWithTypeConversion(
-    rawResult: Record<string, any> | Record<string, any>[],
-    tableSchema: SchemaLike,
-  ): Record<string, any> | Record<string, any>[] {
-    // Build a map of field names to their schema types
-    const fieldTypeMap = new Map();
-    tableSchema.fields.forEach((field: any) => {
-      const fieldName = field.name;
-      const fieldTypeStr = field.type.toString().toLowerCase();
-      fieldTypeMap.set(fieldName, fieldTypeStr);
-    });
-
-    // Handle array case
-    if (Array.isArray(rawResult)) {
-      return rawResult.map(item => this.processResultWithTypeConversion(item, tableSchema));
-    }
-
-    // Handle single record case
-    const processedResult = { ...rawResult };
-
-    // Convert each field according to its schema type
-    for (const key in processedResult) {
-      const fieldTypeStr = fieldTypeMap.get(key);
-      if (!fieldTypeStr) continue;
-
-      // Skip conversion for ID fields - preserve their original format
-      // if (key === 'id') {
-      //   continue;
-      // }
-
-      // Only try to convert string values
-      if (typeof processedResult[key] === 'string') {
-        // Numeric types
-        if (fieldTypeStr.includes('int32') || fieldTypeStr.includes('float32')) {
-          if (!isNaN(Number(processedResult[key]))) {
-            processedResult[key] = Number(processedResult[key]);
-          }
-        } else if (fieldTypeStr.includes('int64')) {
-          processedResult[key] = Number(processedResult[key]);
-        } else if (fieldTypeStr.includes('utf8')) {
-          try {
-            processedResult[key] = JSON.parse(processedResult[key]);
-          } catch (e) {
-            // If JSON parsing fails, keep the original string
-            this.logger.debug(`Failed to parse JSON for key ${key}: ${e}`);
-          }
-        }
-      } else if (typeof processedResult[key] === 'bigint') {
-        // Convert BigInt values to regular numbers for application layer
-        processedResult[key] = Number(processedResult[key]);
-      }
-    }
-
-    return processedResult;
-  }
-
-  getThreadById({ threadId }: { threadId: string }): Promise<StorageThreadType | null> {
-    try {
-      return this.load({ tableName: TABLE_THREADS, keys: { id: threadId } });
-    } catch (error: any) {
-      throw new Error(`Failed to get thread by ID: ${error}`);
-    }
+  async getThreadById({ threadId }: { threadId: string }): Promise<StorageThreadType | null> {
+    return this.stores.memory.getThreadById({ threadId });
   }
 
   async getThreadsByResourceId({ resourceId }: { resourceId: string }): Promise<StorageThreadType[]> {
-    try {
-      const table = await this.lanceClient.openTable(TABLE_THREADS);
-      // fetches all threads with the given resourceId
-      const query = table.query().where(`\`resourceId\` = '${resourceId}'`);
-
-      const records = await query.toArray();
-      return this.processResultWithTypeConversion(
-        records,
-        await this.getTableSchema(TABLE_THREADS),
-      ) as StorageThreadType[];
-    } catch (error: any) {
-      throw new Error(`Failed to get threads by resource ID: ${error}`);
-    }
+    return this.stores.memory.getThreadsByResourceId({ resourceId });
   }
 
   /**
@@ -483,15 +153,7 @@ export class LanceStorage extends MastraStorage {
    * @returns The saved thread
    */
   async saveThread({ thread }: { thread: StorageThreadType }): Promise<StorageThreadType> {
-    try {
-      const record = { ...thread, metadata: JSON.stringify(thread.metadata) };
-      const table = await this.lanceClient.openTable(TABLE_THREADS);
-      await table.add([record], { mode: 'append' });
-
-      return thread;
-    } catch (error: any) {
-      throw new Error(`Failed to save thread: ${error}`);
-    }
+    return this.stores.memory.saveThread({ thread });
   }
 
   async updateThread({
@@ -503,30 +165,41 @@ export class LanceStorage extends MastraStorage {
     title: string;
     metadata: Record<string, unknown>;
   }): Promise<StorageThreadType> {
-    try {
-      const record = { id, title, metadata: JSON.stringify(metadata) };
-      const table = await this.lanceClient.openTable(TABLE_THREADS);
-      await table.add([record], { mode: 'overwrite' });
+    return this.stores.memory.updateThread({ id, title, metadata });
+  }
 
-      const query = table.query().where(`id = '${id}'`);
+  async deleteThread({ threadId }: { threadId: string }): Promise<void> {
+    return this.stores.memory.deleteThread({ threadId });
+  }
 
-      const records = await query.toArray();
-      return this.processResultWithTypeConversion(
-        records[0],
-        await this.getTableSchema(TABLE_THREADS),
-      ) as StorageThreadType;
-    } catch (error: any) {
-      throw new Error(`Failed to update thread: ${error}`);
-    }
+  public get supports() {
+    return {
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: true,
+      createTable: true,
+      deleteMessages: false,
+    };
   }
 
-  async deleteThread({ threadId }: { threadId: string }): Promise<void> {
-    try {
-      const table = await this.lanceClient.openTable(TABLE_THREADS);
-      await table.delete(`id = '${threadId}'`);
-    } catch (error: any) {
-      throw new Error(`Failed to delete thread: ${error}`);
-    }
+  async getResourceById({ resourceId }: { resourceId: string }): Promise<StorageResourceType | null> {
+    return this.stores.memory.getResourceById({ resourceId });
+  }
+
+  async saveResource({ resource }: { resource: StorageResourceType }): Promise<StorageResourceType> {
+    return this.stores.memory.saveResource({ resource });
+  }
+
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata,
+  }: {
+    resourceId: string;
+    workingMemory?: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<StorageResourceType> {
+    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
   }
 
   /**
@@ -556,6 +229,7 @@ export class LanceStorage extends MastraStorage {
 
     for (const item of messagesWithContext) {
       const messageIndex = messageIndexMap.get(item.id);
+
       if (messageIndex !== undefined) {
         // Add previous messages if requested
         if (item.withPreviousMessages) {
@@ -614,69 +288,7 @@ export class LanceStorage extends MastraStorage {
     format,
     threadConfig,
   }: StorageGetMessagesArg & { format?: 'v1' | 'v2' }): Promise<MastraMessageV1[] | MastraMessageV2[]> {
-    try {
-      if (threadConfig) {
-        throw new Error('ThreadConfig is not supported by LanceDB storage');
-      }
-      const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
-      const table = await this.lanceClient.openTable(TABLE_MESSAGES);
-      let query = table.query().where(`\`threadId\` = '${threadId}'`);
-
-      // Apply selectBy filters if provided
-      if (selectBy) {
-        // Handle 'include' to fetch specific messages
-        if (selectBy.include && selectBy.include.length > 0) {
-          const includeIds = selectBy.include.map(item => item.id);
-          // Add additional query to include specific message IDs
-          // This will be combined with the threadId filter
-          const includeClause = includeIds.map(id => `\`id\` = '${id}'`).join(' OR ');
-          query = query.where(`(\`threadId\` = '${threadId}' OR (${includeClause}))`);
-
-          // Note: The surrounding messages (withPreviousMessages/withNextMessages) will be
-          // handled after we retrieve the results
-        }
-      }
-
-      // Fetch all records matching the query
-      let records = await query.toArray();
-
-      // Sort the records chronologically
-      records.sort((a, b) => {
-        const dateA = new Date(a.createdAt).getTime();
-        const dateB = new Date(b.createdAt).getTime();
-        return dateA - dateB; // Ascending order
-      });
-
-      // Process the include.withPreviousMessages and include.withNextMessages if specified
-      if (selectBy?.include && selectBy.include.length > 0) {
-        records = this.processMessagesWithContext(records, selectBy.include);
-      }
-
-      // If we're fetching the last N messages, take only the last N after sorting
-      if (limit !== Number.MAX_SAFE_INTEGER) {
-        records = records.slice(-limit);
-      }
-
-      const messages = this.processResultWithTypeConversion(records, await this.getTableSchema(TABLE_MESSAGES));
-      const normalized = messages.map((msg: MastraMessageV2 | MastraMessageV1) => ({
-        ...msg,
-        content:
-          typeof msg.content === 'string'
-            ? (() => {
-                try {
-                  return JSON.parse(msg.content);
-                } catch {
-                  return msg.content;
-                }
-              })()
-            : msg.content,
-      }));
-      const list = new MessageList({ threadId, resourceId }).add(normalized, 'memory');
-      if (format === 'v2') return list.get.all.v2();
-      return list.get.all.v1();
-    } catch (error: any) {
-      throw new Error(`Failed to get messages: ${error}`);
-    }
+    return this.stores.memory.getMessages({ threadId, resourceId, selectBy, format, threadConfig });
   }
 
   async saveMessages(args: { messages: MastraMessageV1[]; format?: undefined | 'v1' }): Promise<MastraMessageV1[]>;
@@ -684,192 +296,65 @@ export class LanceStorage extends MastraStorage {
   async saveMessages(
     args: { messages: MastraMessageV1[]; format?: undefined | 'v1' } | { messages: MastraMessageV2[]; format: 'v2' },
   ): Promise<MastraMessageV2[] | MastraMessageV1[]> {
-    try {
-      const { messages, format = 'v1' } = args;
-      if (messages.length === 0) {
-        return [];
-      }
-
-      const threadId = messages[0]?.threadId;
-
-      if (!threadId) {
-        throw new Error('Thread ID is required');
-      }
-
-      const transformedMessages = messages.map((message: MastraMessageV2 | MastraMessageV1) => ({
-        ...message,
-        content: JSON.stringify(message.content),
-      }));
+    return this.stores.memory.saveMessages(args);
+  }
 
-      const table = await this.lanceClient.openTable(TABLE_MESSAGES);
-      await table.add(transformedMessages, { mode: 'overwrite' });
-      const list = new MessageList().add(messages, 'memory');
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
-    } catch (error: any) {
-      throw new Error(`Failed to save messages: ${error}`);
-    }
+  async getThreadsByResourceIdPaginated(args: {
+    resourceId: string;
+    page: number;
+    perPage: number;
+  }): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
+    return this.stores.memory.getThreadsByResourceIdPaginated(args);
   }
 
-  async saveTrace({ trace }: { trace: TraceType }): Promise<TraceType> {
-    try {
-      const table = await this.lanceClient.openTable(TABLE_TRACES);
-      const record = {
-        ...trace,
-        attributes: JSON.stringify(trace.attributes),
-        status: JSON.stringify(trace.status),
-        events: JSON.stringify(trace.events),
-        links: JSON.stringify(trace.links),
-        other: JSON.stringify(trace.other),
-      };
-      await table.add([record], { mode: 'append' });
+  async getMessagesPaginated(
+    args: StorageGetMessagesArg & { format?: 'v1' | 'v2' },
+  ): Promise<PaginationInfo & { messages: MastraMessageV1[] | MastraMessageV2[] }> {
+    return this.stores.memory.getMessagesPaginated(args);
+  }
 
-      return trace;
-    } catch (error: any) {
-      throw new Error(`Failed to save trace: ${error}`);
-    }
+  async updateMessages(_args: {
+    messages: Partial<Omit<MastraMessageV2, 'createdAt'>> &
+      {
+        id: string;
+        content?: { metadata?: MastraMessageContentV2['metadata']; content?: MastraMessageContentV2['content'] };
+      }[];
+  }): Promise<MastraMessageV2[]> {
+    return this.stores.memory.updateMessages(_args);
   }
 
-  async getTraceById({ traceId }: { traceId: string }): Promise<TraceType> {
-    try {
-      const table = await this.lanceClient.openTable(TABLE_TRACES);
-      const query = table.query().where(`id = '${traceId}'`);
-      const records = await query.toArray();
-      return this.processResultWithTypeConversion(records[0], await this.getTableSchema(TABLE_TRACES)) as TraceType;
-    } catch (error: any) {
-      throw new Error(`Failed to get trace by ID: ${error}`);
-    }
+  async getTraceById(args: { traceId: string }): Promise<TraceType> {
+    return (this.stores as any).traces.getTraceById(args);
   }
 
-  async getTraces({
-    name,
-    scope,
-    page = 1,
-    perPage = 10,
-    attributes,
-  }: {
+  async getTraces(args: {
     name?: string;
     scope?: string;
     page: number;
     perPage: number;
     attributes?: Record<string, string>;
-  }): Promise<TraceType[]> {
-    try {
-      const table = await this.lanceClient.openTable(TABLE_TRACES);
-      const query = table.query();
-
-      if (name) {
-        query.where(`name = '${name}'`);
-      }
-
-      if (scope) {
-        query.where(`scope = '${scope}'`);
-      }
-
-      if (attributes) {
-        query.where(`attributes = '${JSON.stringify(attributes)}'`);
-      }
-
-      // Calculate offset based on page and perPage
-      const offset = (page - 1) * perPage;
-
-      // Apply limit for pagination
-      query.limit(perPage);
-
-      // Apply offset if greater than 0
-      if (offset > 0) {
-        query.offset(offset);
-      }
-
-      const records = await query.toArray();
-      return records.map(record => {
-        return {
-          ...record,
-          attributes: JSON.parse(record.attributes),
-          status: JSON.parse(record.status),
-          events: JSON.parse(record.events),
-          links: JSON.parse(record.links),
-          other: JSON.parse(record.other),
-          startTime: new Date(record.startTime),
-          endTime: new Date(record.endTime),
-          createdAt: new Date(record.createdAt),
-        };
-      }) as TraceType[];
-    } catch (error: any) {
-      throw new Error(`Failed to get traces: ${error}`);
-    }
+  }): Promise<Trace[]> {
+    return (this.stores as any).traces.getTraces(args);
   }
 
-  async saveEvals({ evals }: { evals: EvalRow[] }): Promise<EvalRow[]> {
-    try {
-      const table = await this.lanceClient.openTable(TABLE_EVALS);
-      const transformedEvals = evals.map(evalRecord => ({
-        input: evalRecord.input,
-        output: evalRecord.output,
-        agent_name: evalRecord.agentName,
-        metric_name: evalRecord.metricName,
-        result: JSON.stringify(evalRecord.result),
-        instructions: evalRecord.instructions,
-        test_info: JSON.stringify(evalRecord.testInfo),
-        global_run_id: evalRecord.globalRunId,
-        run_id: evalRecord.runId,
-        created_at: new Date(evalRecord.createdAt).getTime(),
-      }));
-
-      await table.add(transformedEvals, { mode: 'append' });
-      return evals;
-    } catch (error: any) {
-      throw new Error(`Failed to save evals: ${error}`);
-    }
+  async getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & { traces: Trace[] }> {
+    return (this.stores as any).traces.getTracesPaginated(args);
   }
 
   async getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]> {
-    try {
-      if (type) {
-        this.logger.warn('Type is not implemented yet in LanceDB storage');
-      }
-      const table = await this.lanceClient.openTable(TABLE_EVALS);
-      const query = table.query().where(`agent_name = '${agentName}'`);
-      const records = await query.toArray();
-      return records.map(record => {
-        return {
-          id: record.id,
-          input: record.input,
-          output: record.output,
-          agentName: record.agent_name,
-          metricName: record.metric_name,
-          result: JSON.parse(record.result),
-          instructions: record.instructions,
-          testInfo: JSON.parse(record.test_info),
-          globalRunId: record.global_run_id,
-          runId: record.run_id,
-          createdAt: new Date(record.created_at).toString(),
-        };
-      }) as EvalRow[];
-    } catch (error: any) {
-      throw new Error(`Failed to get evals by agent name: ${error}`);
-    }
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
   }
 
-  private parseWorkflowRun(row: any): WorkflowRun {
-    let parsedSnapshot: WorkflowRunState | string = row.snapshot as string;
-    if (typeof parsedSnapshot === 'string') {
-      try {
-        parsedSnapshot = JSON.parse(row.snapshot as string) as WorkflowRunState;
-      } catch (e) {
-        // If parsing fails, return the raw snapshot string
-        console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
-      }
-    }
-
-    return {
-      workflowName: row.workflow_name,
-      runId: row.run_id,
-      snapshot: parsedSnapshot,
-      createdAt: this.ensureDate(row.createdAt)!,
-      updatedAt: this.ensureDate(row.updatedAt)!,
-      resourceId: row.resourceId,
-    };
+  async getEvals(options: {
+    agentName?: string;
+    type?: 'test' | 'live';
+    page?: number;
+    perPage?: number;
+    fromDate?: Date;
+    toDate?: Date;
+    dateRange?: { start?: Date; end?: Date };
+  }): Promise<PaginationInfo & { evals: EvalRow[] }> {
+    return this.stores.legacyEvals.getEvals(options);
   }
 
   async getWorkflowRuns(args?: {
@@ -880,45 +365,9 @@ export class LanceStorage extends MastraStorage {
     limit?: number;
     offset?: number;
   }): Promise<WorkflowRuns> {
-    try {
-      const table = await this.lanceClient.openTable(TABLE_WORKFLOW_SNAPSHOT);
-      const query = table.query();
-
-      if (args?.workflowName) {
-        query.where(`workflow_name = '${args.workflowName}'`);
-      }
-
-      if (args?.fromDate) {
-        query.where(`\`createdAt\` >= ${args.fromDate.getTime()}`);
-      }
-
-      if (args?.toDate) {
-        query.where(`\`createdAt\` <= ${args.toDate.getTime()}`);
-      }
-
-      if (args?.limit) {
-        query.limit(args.limit);
-      }
-
-      if (args?.offset) {
-        query.offset(args.offset);
-      }
-
-      const records = await query.toArray();
-      return {
-        runs: records.map(record => this.parseWorkflowRun(record)),
-        total: records.length,
-      };
-    } catch (error: any) {
-      throw new Error(`Failed to get workflow runs: ${error}`);
-    }
+    return this.stores.workflows.getWorkflowRuns(args);
   }
 
-  /**
-   * Retrieve a single workflow run by its runId.
-   * @param args The ID of the workflow run to retrieve
-   * @returns The workflow run object or null if not found
-   */
   async getWorkflowRunById(args: { runId: string; workflowName?: string }): Promise<{
     workflowName: string;
     runId: string;
@@ -926,20 +375,7 @@ export class LanceStorage extends MastraStorage {
     createdAt: Date;
     updatedAt: Date;
   } | null> {
-    try {
-      const table = await this.lanceClient.openTable(TABLE_WORKFLOW_SNAPSHOT);
-      let whereClause = `run_id = '${args.runId}'`;
-      if (args.workflowName) {
-        whereClause += ` AND workflow_name = '${args.workflowName}'`;
-      }
-      const query = table.query().where(whereClause);
-      const records = await query.toArray();
-      if (records.length === 0) return null;
-      const record = records[0];
-      return this.parseWorkflowRun(record);
-    } catch (error: any) {
-      throw new Error(`Failed to get workflow run by id: ${error}`);
-    }
+    return this.stores.workflows.getWorkflowRunById(args);
   }
 
   async persistWorkflowSnapshot({
@@ -951,36 +387,9 @@ export class LanceStorage extends MastraStorage {
     runId: string;
     snapshot: WorkflowRunState;
   }): Promise<void> {
-    try {
-      const table = await this.lanceClient.openTable(TABLE_WORKFLOW_SNAPSHOT);
-
-      // Try to find the existing record
-      const query = table.query().where(`workflow_name = '${workflowName}' AND run_id = '${runId}'`);
-      const records = await query.toArray();
-      let createdAt: number;
-      const now = Date.now();
-      let mode: 'append' | 'overwrite' = 'append';
-
-      if (records.length > 0) {
-        createdAt = records[0].createdAt ?? now;
-        mode = 'overwrite';
-      } else {
-        createdAt = now;
-      }
-
-      const record = {
-        workflow_name: workflowName,
-        run_id: runId,
-        snapshot: JSON.stringify(snapshot),
-        createdAt,
-        updatedAt: now,
-      };
-
-      await table.add([record], { mode });
-    } catch (error: any) {
-      throw new Error(`Failed to persist workflow snapshot: ${error}`);
-    }
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
   }
+
   async loadWorkflowSnapshot({
     workflowName,
     runId,
@@ -988,42 +397,46 @@ export class LanceStorage extends MastraStorage {
     workflowName: string;
     runId: string;
   }): Promise<WorkflowRunState | null> {
-    try {
-      const table = await this.lanceClient.openTable(TABLE_WORKFLOW_SNAPSHOT);
-      const query = table.query().where(`workflow_name = '${workflowName}' AND run_id = '${runId}'`);
-      const records = await query.toArray();
-      return records.length > 0 ? JSON.parse(records[0].snapshot) : null;
-    } catch (error: any) {
-      throw new Error(`Failed to load workflow snapshot: ${error}`);
-    }
+    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
   }
 
-  async getTracesPaginated(_args: StorageGetTracesArg): Promise<PaginationInfo & { traces: Trace[] }> {
-    throw new Error('Method not implemented.');
+  async getScoreById({ id: _id }: { id: string }): Promise<ScoreRowData | null> {
+    return this.stores.scores.getScoreById({ id: _id });
   }
 
-  async getThreadsByResourceIdPaginated(_args: {
-    resourceId: string;
-    page?: number;
-    perPage?: number;
-  }): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
-    throw new Error('Method not implemented.');
+  async getScoresByScorerId({
+    scorerId,
+    pagination,
+  }: {
+    scorerId: string;
+    pagination: StoragePagination;
+  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
+    return this.stores.scores.getScoresByScorerId({ scorerId, pagination });
   }
 
-  async getMessagesPaginated(
-    _args: StorageGetMessagesArg,
-  ): Promise<PaginationInfo & { messages: MastraMessageV1[] | MastraMessageV2[] }> {
-    throw new Error('Method not implemented.');
+  async saveScore(_score: ScoreRowData): Promise<{ score: ScoreRowData }> {
+    return this.stores.scores.saveScore(_score);
   }
 
-  async updateMessages(_args: {
-    messages: Partial<Omit<MastraMessageV2, 'createdAt'>> &
-      {
-        id: string;
-        content?: { metadata?: MastraMessageContentV2['metadata']; content?: MastraMessageContentV2['content'] };
-      }[];
-  }): Promise<MastraMessageV2[]> {
-    this.logger.error('updateMessages is not yet implemented in LanceStore');
-    throw new Error('Method not implemented');
+  async getScoresByRunId({
+    runId,
+    pagination,
+  }: {
+    runId: string;
+    pagination: StoragePagination;
+  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
+    return this.stores.scores.getScoresByRunId({ runId, pagination });
+  }
+
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination,
+  }: {
+    pagination: StoragePagination;
+    entityId: string;
+    entityType: string;
+  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
+    return this.stores.scores.getScoresByEntityId({ entityId, entityType, pagination });
   }
 }