@mastra/libsql 0.10.0 → 0.10.1-alpha.1

package/dist/index.js

@@ -482,11 +482,15 @@ var processOperator = (key, operator, operatorValue) => {
 // src/vector/index.ts
 var LibSQLVector = class extends MastraVector {
   turso;
+  maxRetries;
+  initialBackoffMs;
   constructor({
     connectionUrl,
     authToken,
     syncUrl,
-    syncInterval
+    syncInterval,
+    maxRetries = 5,
+    initialBackoffMs = 100
   }) {
     super();
     this.turso = createClient({
@@ -495,12 +499,40 @@ var LibSQLVector = class extends MastraVector {
       authToken,
       syncInterval
     });
+    this.maxRetries = maxRetries;
+    this.initialBackoffMs = initialBackoffMs;
     if (connectionUrl.includes(`file:`) || connectionUrl.includes(`:memory:`)) {
-      void this.turso.execute({
-        sql: "PRAGMA journal_mode=WAL;",
-        args: {}
-      });
+      this.turso.execute("PRAGMA journal_mode=WAL;").then(() => this.logger.debug("LibSQLStore: PRAGMA journal_mode=WAL set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA journal_mode=WAL.", err));
+      this.turso.execute("PRAGMA busy_timeout = 5000;").then(() => this.logger.debug("LibSQLStore: PRAGMA busy_timeout=5000 set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA busy_timeout=5000.", err));
+    }
+  }
+  async executeWriteOperationWithRetry(operation, isTransaction = false) {
+    let attempts = 0;
+    let backoff = this.initialBackoffMs;
+    while (attempts < this.maxRetries) {
+      try {
+        return await operation();
+      } catch (error) {
+        if (error.code === "SQLITE_BUSY" || error.message && error.message.toLowerCase().includes("database is locked")) {
+          attempts++;
+          if (attempts >= this.maxRetries) {
+            this.logger.error(
+              `LibSQLVector: Operation failed after ${this.maxRetries} attempts due to: ${error.message}`,
+              error
+            );
+            throw error;
+          }
+          this.logger.warn(
+            `LibSQLVector: Attempt ${attempts} failed due to ${isTransaction ? "transaction " : ""}database lock. Retrying in ${backoff}ms...`
+          );
+          await new Promise((resolve) => setTimeout(resolve, backoff));
+          backoff *= 2;
+        } else {
+          throw error;
+        }
+      }
     }
+    throw new Error("LibSQLVector: Max retries reached, but no error was re-thrown from the loop.");
   }
   transformFilter(filter) {
     const translator = new LibSQLFilterTranslator();
@@ -528,20 +560,20 @@ var LibSQLVector = class extends MastraVector {
       filterValues.push(minScore);
       filterValues.push(topK);
       const query = `
-        WITH vector_scores AS (
-          SELECT
-            vector_id as id,
-            (1-vector_distance_cos(embedding, '${vectorStr}')) as score,
-            metadata
-            ${includeVector ? ", vector_extract(embedding) as embedding" : ""}
-          FROM ${parsedIndexName}
-          ${filterQuery}
-        )
-        SELECT *
-        FROM vector_scores
-        WHERE score > ?
-        ORDER BY score DESC
-        LIMIT ?`;
+      WITH vector_scores AS (
+        SELECT
+          vector_id as id,
+          (1-vector_distance_cos(embedding, '${vectorStr}')) as score,
+          metadata
+          ${includeVector ? ", vector_extract(embedding) as embedding" : ""}
+        FROM ${parsedIndexName}
+        ${filterQuery}
+      )
+      SELECT *
+      FROM vector_scores
+      WHERE score > ?
+      ORDER BY score DESC
+      LIMIT ?`;
       const result = await this.turso.execute({
         sql: query,
         args: filterValues
@@ -555,22 +587,24 @@ var LibSQLVector = class extends MastraVector {
     } finally {
     }
   }
-  async upsert({ indexName, vectors, metadata, ids }) {
+  upsert(args) {
+    return this.executeWriteOperationWithRetry(() => this.doUpsert(args), true);
+  }
+  async doUpsert({ indexName, vectors, metadata, ids }) {
     const tx = await this.turso.transaction("write");
     try {
       const parsedIndexName = parseSqlIdentifier(indexName, "index name");
       const vectorIds = ids || vectors.map(() => crypto.randomUUID());
       for (let i = 0; i < vectors.length; i++) {
         const query = `
-          INSERT INTO ${parsedIndexName} (vector_id, embedding, metadata)
-          VALUES (?, vector32(?), ?)
-          ON CONFLICT(vector_id) DO UPDATE SET
-            embedding = vector32(?),
-            metadata = ?
-        `;
+            INSERT INTO ${parsedIndexName} (vector_id, embedding, metadata)
+            VALUES (?, vector32(?), ?)
+            ON CONFLICT(vector_id) DO UPDATE SET
+              embedding = vector32(?),
+              metadata = ?
+          `;
         await tx.execute({
           sql: query,
-          // @ts-ignore
           args: [
             vectorIds[i],
             JSON.stringify(vectors[i]),
@@ -596,48 +630,42 @@ var LibSQLVector = class extends MastraVector {
       throw error;
     }
   }
-  async createIndex({ indexName, dimension }) {
-    try {
-      if (!Number.isInteger(dimension) || dimension <= 0) {
-        throw new Error("Dimension must be a positive integer");
-      }
-      const parsedIndexName = parseSqlIdentifier(indexName, "index name");
-      await this.turso.execute({
-        sql: `
-        CREATE TABLE IF NOT EXISTS ${parsedIndexName} (
-          id SERIAL PRIMARY KEY,
-          vector_id TEXT UNIQUE NOT NULL,
-          embedding F32_BLOB(${dimension}),
-          metadata TEXT DEFAULT '{}'
-        );
-      `,
-        args: []
-      });
-      await this.turso.execute({
-        sql: `
-        CREATE INDEX IF NOT EXISTS ${parsedIndexName}_vector_idx
-        ON ${parsedIndexName} (libsql_vector_idx(embedding))
-      `,
-        args: []
-      });
-    } catch (error) {
-      console.error("Failed to create vector table:", error);
-      throw error;
-    } finally {
-    }
+  createIndex(args) {
+    return this.executeWriteOperationWithRetry(() => this.doCreateIndex(args));
   }
-  async deleteIndex({ indexName }) {
-    try {
-      const parsedIndexName = parseSqlIdentifier(indexName, "index name");
-      await this.turso.execute({
-        sql: `DROP TABLE IF EXISTS ${parsedIndexName}`,
-        args: []
-      });
-    } catch (error) {
-      console.error("Failed to delete vector table:", error);
-      throw new Error(`Failed to delete vector table: ${error.message}`);
-    } finally {
+  async doCreateIndex({ indexName, dimension }) {
+    if (!Number.isInteger(dimension) || dimension <= 0) {
+      throw new Error("Dimension must be a positive integer");
     }
+    const parsedIndexName = parseSqlIdentifier(indexName, "index name");
+    await this.turso.execute({
+      sql: `
+          CREATE TABLE IF NOT EXISTS ${parsedIndexName} (
+            id SERIAL PRIMARY KEY,
+            vector_id TEXT UNIQUE NOT NULL,
+            embedding F32_BLOB(${dimension}),
+            metadata TEXT DEFAULT '{}'
+          );
+        `,
+      args: []
+    });
+    await this.turso.execute({
+      sql: `
+          CREATE INDEX IF NOT EXISTS ${parsedIndexName}_vector_idx
+          ON ${parsedIndexName} (libsql_vector_idx(embedding))
+        `,
+      args: []
+    });
+  }
+  deleteIndex(args) {
+    return this.executeWriteOperationWithRetry(() => this.doDeleteIndex(args));
+  }
+  async doDeleteIndex({ indexName }) {
+    const parsedIndexName = parseSqlIdentifier(indexName, "index name");
+    await this.turso.execute({
+      sql: `DROP TABLE IF EXISTS ${parsedIndexName}`,
+      args: []
+    });
   }
   async listIndexes() {
     try {
@@ -707,35 +735,34 @@ var LibSQLVector = class extends MastraVector {
    * @returns A promise that resolves when the update is complete.
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
-  async updateVector({ indexName, id, update }) {
-    try {
-      const parsedIndexName = parseSqlIdentifier(indexName, "index name");
-      const updates = [];
-      const args = [];
-      if (update.vector) {
-        updates.push("embedding = vector32(?)");
-        args.push(JSON.stringify(update.vector));
-      }
-      if (update.metadata) {
-        updates.push("metadata = ?");
-        args.push(JSON.stringify(update.metadata));
-      }
-      if (updates.length === 0) {
-        throw new Error("No updates provided");
-      }
-      args.push(id);
-      const query = `
+  updateVector(args) {
+    return this.executeWriteOperationWithRetry(() => this.doUpdateVector(args));
+  }
+  async doUpdateVector({ indexName, id, update }) {
+    const parsedIndexName = parseSqlIdentifier(indexName, "index name");
+    const updates = [];
+    const args = [];
+    if (update.vector) {
+      updates.push("embedding = vector32(?)");
+      args.push(JSON.stringify(update.vector));
+    }
+    if (update.metadata) {
+      updates.push("metadata = ?");
+      args.push(JSON.stringify(update.metadata));
+    }
+    if (updates.length === 0) {
+      throw new Error("No updates provided");
+    }
+    args.push(id);
+    const query = `
         UPDATE ${parsedIndexName}
         SET ${updates.join(", ")}
         WHERE vector_id = ?;
       `;
-      await this.turso.execute({
-        sql: query,
-        args
-      });
-    } catch (error) {
-      throw new Error(`Failed to update vector by id: ${id} for index: ${indexName}: ${error.message}`);
-    }
+    await this.turso.execute({
+      sql: query,
+      args
+    });
   }
   /**
    * Deletes a vector by its ID.
@@ -744,18 +771,20 @@ var LibSQLVector = class extends MastraVector {
    * @returns A promise that resolves when the deletion is complete.
    * @throws Will throw an error if the deletion operation fails.
    */
-  async deleteVector({ indexName, id }) {
-    try {
-      const parsedIndexName = parseSqlIdentifier(indexName, "index name");
-      await this.turso.execute({
-        sql: `DELETE FROM ${parsedIndexName} WHERE vector_id = ?`,
-        args: [id]
-      });
-    } catch (error) {
-      throw new Error(`Failed to delete vector by id: ${id} for index: ${indexName}: ${error.message}`);
-    }
+  deleteVector(args) {
+    return this.executeWriteOperationWithRetry(() => this.doDeleteVector(args));
+  }
+  async doDeleteVector({ indexName, id }) {
+    const parsedIndexName = parseSqlIdentifier(indexName, "index name");
+    await this.turso.execute({
+      sql: `DELETE FROM ${parsedIndexName} WHERE vector_id = ?`,
+      args: [id]
+    });
+  }
+  truncateIndex(args) {
+    return this.executeWriteOperationWithRetry(() => this._doTruncateIndex(args));
   }
-  async truncateIndex({ indexName }) {
+  async _doTruncateIndex({ indexName }) {
     await this.turso.execute({
       sql: `DELETE FROM ${parseSqlIdentifier(indexName, "index name")}`,
       args: []
@@ -771,12 +800,20 @@ function safelyParseJSON(jsonString) {
 }
 var LibSQLStore = class extends MastraStorage {
   client;
+  maxRetries;
+  initialBackoffMs;
   constructor(config) {
     super({ name: `LibSQLStore` });
+    this.maxRetries = config.maxRetries ?? 5;
+    this.initialBackoffMs = config.initialBackoffMs ?? 100;
     if (config.url.endsWith(":memory:")) {
       this.shouldCacheInit = false;
     }
     this.client = createClient(config);
+    if (config.url.startsWith("file:") || config.url.includes(":memory:")) {
+      this.client.execute("PRAGMA journal_mode=WAL;").then(() => this.logger.debug("LibSQLStore: PRAGMA journal_mode=WAL set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA journal_mode=WAL.", err));
+      this.client.execute("PRAGMA busy_timeout = 5000;").then(() => this.logger.debug("LibSQLStore: PRAGMA busy_timeout=5000 set.")).catch((err) => this.logger.warn("LibSQLStore: Failed to set PRAGMA busy_timeout.", err));
+    }
   }
   getCreateTableSQL(tableName, schema) {
     const parsedTableName = parseSqlIdentifier(tableName, "table name");
@@ -839,28 +876,53 @@ var LibSQLStore = class extends MastraStorage {
       args: values
     };
   }
-  async insert({ tableName, record }) {
-    try {
-      await this.client.execute(
-        this.prepareStatement({
-          tableName,
-          record
-        })
-      );
-    } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
+  async executeWriteOperationWithRetry(operationFn, operationDescription) {
+    let retries = 0;
+    while (true) {
+      try {
+        return await operationFn();
+      } catch (error) {
+        if (error.message && (error.message.includes("SQLITE_BUSY") || error.message.includes("database is locked")) && retries < this.maxRetries) {
+          retries++;
+          const backoffTime = this.initialBackoffMs * Math.pow(2, retries - 1);
+          this.logger.warn(
+            `LibSQLStore: Encountered SQLITE_BUSY during ${operationDescription}. Retrying (${retries}/${this.maxRetries}) in ${backoffTime}ms...`
+          );
+          await new Promise((resolve) => setTimeout(resolve, backoffTime));
+        } else {
+          this.logger.error(`LibSQLStore: Error during ${operationDescription} after ${retries} retries: ${error}`);
+          throw error;
+        }
+      }
     }
   }
-  async batchInsert({ tableName, records }) {
+  insert(args) {
+    return this.executeWriteOperationWithRetry(() => this.doInsert(args), `insert into table ${args.tableName}`);
+  }
+  async doInsert({
+    tableName,
+    record
+  }) {
+    await this.client.execute(
+      this.prepareStatement({
+        tableName,
+        record
+      })
+    );
+  }
+  batchInsert(args) {
+    return this.executeWriteOperationWithRetry(
+      () => this.doBatchInsert(args),
+      `batch insert into table ${args.tableName}`
+    );
+  }
+  async doBatchInsert({
+    tableName,
+    records
+  }) {
     if (records.length === 0) return;
-    try {
-      const batchStatements = records.map((r) => this.prepareStatement({ tableName, record: r }));
-      await this.client.batch(batchStatements, "write");
-    } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
-    }
+    const batchStatements = records.map((r) => this.prepareStatement({ tableName, record: r }));
+    await this.client.batch(batchStatements, "write");
   }
   async load({ tableName, keys }) {
     const parsedTableName = parseSqlIdentifier(tableName, "table name");
@@ -961,14 +1023,15 @@ var LibSQLStore = class extends MastraStorage {
       content = JSON.parse(row.content);
     } catch {
     }
-    return {
+    const result = {
       id: row.id,
       content,
       role: row.role,
-      type: row.type,
       createdAt: new Date(row.createdAt),
       threadId: row.thread_id
     };
+    if (row.type && row.type !== `v2`) result.type = row.type;
+    return result;
   }
   async getMessages({ threadId, selectBy }) {
     try {
@@ -1056,7 +1119,7 @@ var LibSQLStore = class extends MastraStorage {
             threadId,
             typeof message.content === "object" ? JSON.stringify(message.content) : message.content,
             message.role,
-            message.type,
+            message.type || "v2",
             time instanceof Date ? time.toISOString() : time
           ]
         };
@@ -1288,8 +1351,8 @@ var LibSQLStore = class extends MastraStorage {
       runId: row.run_id,
       snapshot: parsedSnapshot,
       resourceId: row.resourceId,
-      createdAt: new Date(row.created_at),
-      updatedAt: new Date(row.updated_at)
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
     };
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/libsql",
-  "version": "0.10.0",
+  "version": "0.10.1-alpha.1",
   "description": "Libsql provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -29,12 +29,12 @@
     "tsup": "^8.4.0",
     "typescript": "^5.8.3",
     "vitest": "^3.1.2",
-    "@internal/lint": "0.0.6",
-    "@internal/storage-test-utils": "0.0.2",
-    "@mastra/core": "0.10.0"
+    "@internal/lint": "0.0.7",
+    "@internal/storage-test-utils": "0.0.3",
+    "@mastra/core": "0.10.2-alpha.2"
   },
   "peerDependencies": {
-    "@mastra/core": "^0.10.0"
+    "@mastra/core": "^0.10.0-alpha.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/storage/index.test.ts

@@ -1,6 +1,5 @@
 import { createTestSuite } from '@internal/storage-test-utils';
 import { Mastra } from '@mastra/core/mastra';
-
 import { LibSQLStore } from './index';
 
 // Test database configuration

package/src/storage/index.ts

@@ -1,7 +1,8 @@
 import { createClient } from '@libsql/client';
 import type { Client, InValue } from '@libsql/client';
+import type { MastraMessageV2 } from '@mastra/core/agent';
 import type { MetricResult, TestInfo } from '@mastra/core/eval';
-import type { MessageType, StorageThreadType } from '@mastra/core/memory';
+import type { StorageThreadType } from '@mastra/core/memory';
 import {
   MastraStorage,
   TABLE_MESSAGES,
@@ -32,20 +33,48 @@ function safelyParseJSON(jsonString: string): any {
 export interface LibSQLConfig {
   url: string;
   authToken?: string;
+  /**
+   * Maximum number of retries for write operations if an SQLITE_BUSY error occurs.
+   * @default 5
+   */
+  maxRetries?: number;
+  /**
+   * Initial backoff time in milliseconds for retrying write operations on SQLITE_BUSY.
+   * The backoff time will double with each retry (exponential backoff).
+   * @default 100
+   */
+  initialBackoffMs?: number;
 }
 
 export class LibSQLStore extends MastraStorage {
   private client: Client;
+  private readonly maxRetries: number;
+  private readonly initialBackoffMs: number;
 
   constructor(config: LibSQLConfig) {
     super({ name: `LibSQLStore` });
 
+    this.maxRetries = config.maxRetries ?? 5;
+    this.initialBackoffMs = config.initialBackoffMs ?? 100;
+
     // need to re-init every time for in memory dbs or the tables might not exist
     if (config.url.endsWith(':memory:')) {
       this.shouldCacheInit = false;
     }
 
     this.client = createClient(config);
+
+    // Set PRAGMAs for better concurrency, especially for file-based databases
+    if (config.url.startsWith('file:') || config.url.includes(':memory:')) {
+      this.client
+        .execute('PRAGMA journal_mode=WAL;')
+        .then(() => this.logger.debug('LibSQLStore: PRAGMA journal_mode=WAL set.'))
+        .catch(err => this.logger.warn('LibSQLStore: Failed to set PRAGMA journal_mode=WAL.', err));
+      this.client
+        .execute('PRAGMA busy_timeout = 5000;') // 5 seconds
+        .then(() => this.logger.debug('LibSQLStore: PRAGMA busy_timeout=5000 set.'))
+        .catch(err => this.logger.warn('LibSQLStore: Failed to set PRAGMA busy_timeout.', err));
+    }
   }
 
   private getCreateTableSQL(tableName: TABLE_NAMES, schema: Record<string, StorageColumn>): string {
@@ -127,30 +156,71 @@ export class LibSQLStore extends MastraStorage {
     };
   }
 
-  async insert({ tableName, record }: { tableName: TABLE_NAMES; record: Record<string, any> }): Promise<void> {
-    try {
-      await this.client.execute(
-        this.prepareStatement({
-          tableName,
-          record,
-        }),
-      );
-    } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
+  private async executeWriteOperationWithRetry<T>(
+    operationFn: () => Promise<T>,
+    operationDescription: string,
+  ): Promise<T> {
+    let retries = 0;
+
+    while (true) {
+      try {
+        return await operationFn();
+      } catch (error: any) {
+        if (
+          error.message &&
+          (error.message.includes('SQLITE_BUSY') || error.message.includes('database is locked')) &&
+          retries < this.maxRetries
+        ) {
+          retries++;
+          const backoffTime = this.initialBackoffMs * Math.pow(2, retries - 1);
+          this.logger.warn(
+            `LibSQLStore: Encountered SQLITE_BUSY during ${operationDescription}. Retrying (${retries}/${this.maxRetries}) in ${backoffTime}ms...`,
+          );
+          await new Promise(resolve => setTimeout(resolve, backoffTime));
+        } else {
+          this.logger.error(`LibSQLStore: Error during ${operationDescription} after ${retries} retries: ${error}`);
+          throw error;
+        }
+      }
     }
   }
 
-  async batchInsert({ tableName, records }: { tableName: TABLE_NAMES; records: Record<string, any>[] }): Promise<void> {
-    if (records.length === 0) return;
+  public insert(args: { tableName: TABLE_NAMES; record: Record<string, any> }): Promise<void> {
+    return this.executeWriteOperationWithRetry(() => this.doInsert(args), `insert into table ${args.tableName}`);
+  }
 
-    try {
-      const batchStatements = records.map(r => this.prepareStatement({ tableName, record: r }));
-      await this.client.batch(batchStatements, 'write');
-    } catch (error) {
-      this.logger.error(`Error upserting into table ${tableName}: ${error}`);
-      throw error;
-    }
+  private async doInsert({
+    tableName,
+    record,
+  }: {
+    tableName: TABLE_NAMES;
+    record: Record<string, any>;
+  }): Promise<void> {
+    await this.client.execute(
+      this.prepareStatement({
+        tableName,
+        record,
+      }),
+    );
+  }
+
+  public batchInsert(args: { tableName: TABLE_NAMES; records: Record<string, any>[] }): Promise<void> {
+    return this.executeWriteOperationWithRetry(
+      () => this.doBatchInsert(args),
+      `batch insert into table ${args.tableName}`,
+    );
+  }
+
+  private async doBatchInsert({
+    tableName,
+    records,
+  }: {
+    tableName: TABLE_NAMES;
+    records: Record<string, any>[];
+  }): Promise<void> {
+    if (records.length === 0) return;
+    const batchStatements = records.map(r => this.prepareStatement({ tableName, record: r }));
+    await this.client.batch(batchStatements, 'write');
   }
 
   async load<R>({ tableName, keys }: { tableName: TABLE_NAMES; keys: Record<string, string> }): Promise<R | null> {
@@ -274,26 +344,27 @@ export class LibSQLStore extends MastraStorage {
     // Messages will be automatically deleted due to CASCADE constraint
   }
 
-  private parseRow(row: any): MessageType {
+  private parseRow(row: any): MastraMessageV2 {
     let content = row.content;
     try {
       content = JSON.parse(row.content);
     } catch {
       // use content as is if it's not JSON
     }
-    return {
+    const result = {
       id: row.id,
       content,
       role: row.role,
-      type: row.type,
       createdAt: new Date(row.createdAt as string),
       threadId: row.thread_id,
-    } as MessageType;
+    } as MastraMessageV2;
+    if (row.type && row.type !== `v2`) result.type = row.type;
+    return result;
   }
 
-  async getMessages<T extends MessageType[]>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T> {
+  async getMessages<T extends MastraMessageV2[]>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T> {
     try {
-      const messages: MessageType[] = [];
+      const messages: MastraMessageV2[] = [];
       const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
 
       // If we have specific messages to select
@@ -373,7 +444,7 @@ export class LibSQLStore extends MastraStorage {
     }
   }
 
-  async saveMessages({ messages }: { messages: MessageType[] }): Promise<MessageType[]> {
+  async saveMessages({ messages }: { messages: MastraMessageV2[] }): Promise<MastraMessageV2[]> {
     if (messages.length === 0) return messages;
 
     try {
@@ -393,7 +464,7 @@ export class LibSQLStore extends MastraStorage {
             threadId,
             typeof message.content === 'object' ? JSON.stringify(message.content) : message.content,
             message.role,
-            message.type,
+            message.type || 'v2',
             time instanceof Date ? time.toISOString() : time,
           ],
         };
@@ -701,8 +772,8 @@ export class LibSQLStore extends MastraStorage {
       runId: row.run_id as string,
       snapshot: parsedSnapshot,
       resourceId: row.resourceId as string,
-      createdAt: new Date(row.created_at as string),
-      updatedAt: new Date(row.updated_at as string),
+      createdAt: new Date(row.createdAt as string),
+      updatedAt: new Date(row.updatedAt as string),
     };
   }
 }