@mastra/libsql 0.11.0 → 0.11.1-alpha.0

package/dist/index.js

@@ -3,8 +3,9 @@ import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { parseSqlIdentifier, parseFieldKey } from '@mastra/core/utils';
 import { MastraVector } from '@mastra/core/vector';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import { MastraStorage, StoreOperations, TABLE_WORKFLOW_SNAPSHOT, ScoresStorage, TABLE_SCORERS, TracesStorage, TABLE_TRACES, safelyParseJSON, WorkflowsStorage, MemoryStorage, resolveMessageLimit, TABLE_MESSAGES, TABLE_THREADS, TABLE_RESOURCES, LegacyEvalsStorage, TABLE_EVALS } from '@mastra/core/storage';
+import { parseSqlIdentifier as parseSqlIdentifier$1 } from '@mastra/core';
 import { MessageList } from '@mastra/core/agent';
-import { MastraStorage, TABLE_WORKFLOW_SNAPSHOT, TABLE_THREADS, TABLE_MESSAGES, TABLE_EVALS, TABLE_TRACES, TABLE_RESOURCES } from '@mastra/core/storage';
 
 // src/vector/index.ts
 var LibSQLFilterTranslator = class extends BaseFilterTranslator {
@@ -904,256 +905,542 @@ var LibSQLVector = class extends MastraVector {
     });
   }
 };
-function safelyParseJSON(jsonString) {
-  try {
-    return JSON.parse(jsonString);
-  } catch {
-    return {};
+function transformEvalRow(row) {
+  const resultValue = JSON.parse(row.result);
+  const testInfoValue = row.test_info ? JSON.parse(row.test_info) : void 0;
+  if (!resultValue || typeof resultValue !== "object" || !("score" in resultValue)) {
+    throw new Error(`Invalid MetricResult format: ${JSON.stringify(resultValue)}`);
   }
+  return {
+    input: row.input,
+    output: row.output,
+    result: resultValue,
+    agentName: row.agent_name,
+    metricName: row.metric_name,
+    instructions: row.instructions,
+    testInfo: testInfoValue,
+    globalRunId: row.global_run_id,
+    runId: row.run_id,
+    createdAt: row.created_at
+  };
 }
-var LibSQLStore = class extends MastraStorage {
+var LegacyEvalsLibSQL = class extends LegacyEvalsStorage {
   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));
-    }
-  }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true
-    };
+  constructor({ client }) {
+    super();
+    this.client = client;
   }
-  getCreateTableSQL(tableName, schema) {
-    const parsedTableName = parseSqlIdentifier(tableName, "table name");
-    const columns = Object.entries(schema).map(([name, col]) => {
-      const parsedColumnName = parseSqlIdentifier(name, "column name");
-      let type = col.type.toUpperCase();
-      if (type === "TEXT") type = "TEXT";
-      if (type === "TIMESTAMP") type = "TEXT";
-      const nullable = col.nullable ? "" : "NOT NULL";
-      const primaryKey = col.primaryKey ? "PRIMARY KEY" : "";
-      return `${parsedColumnName} ${type} ${nullable} ${primaryKey}`.trim();
-    });
-    if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
-      const stmnt = `CREATE TABLE IF NOT EXISTS ${parsedTableName} (
-                ${columns.join(",\n")},
-                PRIMARY KEY (workflow_name, run_id)
-            )`;
-      return stmnt;
+  /** @deprecated use getEvals instead */
+  async getEvalsByAgentName(agentName, type) {
+    try {
+      const baseQuery = `SELECT * FROM ${TABLE_EVALS} WHERE agent_name = ?`;
+      const typeCondition = type === "test" ? " AND test_info IS NOT NULL AND test_info->>'testPath' IS NOT NULL" : type === "live" ? " AND (test_info IS NULL OR test_info->>'testPath' IS NULL)" : "";
+      const result = await this.client.execute({
+        sql: `${baseQuery}${typeCondition} ORDER BY created_at DESC`,
+        args: [agentName]
+      });
+      return result.rows?.map((row) => transformEvalRow(row)) ?? [];
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("no such table")) {
+        return [];
+      }
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_GET_EVALS_BY_AGENT_NAME_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentName }
+        },
+        error
+      );
     }
-    return `CREATE TABLE IF NOT EXISTS ${parsedTableName} (${columns.join(", ")})`;
   }
-  async createTable({
-    tableName,
-    schema
-  }) {
+  async getEvals(options = {}) {
+    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const conditions = [];
+    const queryParams = [];
+    if (agentName) {
+      conditions.push(`agent_name = ?`);
+      queryParams.push(agentName);
+    }
+    if (type === "test") {
+      conditions.push(`(test_info IS NOT NULL AND json_extract(test_info, '$.testPath') IS NOT NULL)`);
+    } else if (type === "live") {
+      conditions.push(`(test_info IS NULL OR json_extract(test_info, '$.testPath') IS NULL)`);
+    }
+    if (fromDate) {
+      conditions.push(`created_at >= ?`);
+      queryParams.push(fromDate.toISOString());
+    }
+    if (toDate) {
+      conditions.push(`created_at <= ?`);
+      queryParams.push(toDate.toISOString());
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
     try {
-      this.logger.debug(`Creating database table`, { tableName, operation: "schema init" });
-      const sql = this.getCreateTableSQL(tableName, schema);
-      await this.client.execute(sql);
+      const countResult = await this.client.execute({
+        sql: `SELECT COUNT(*) as count FROM ${TABLE_EVALS} ${whereClause}`,
+        args: queryParams
+      });
+      const total = Number(countResult.rows?.[0]?.count ?? 0);
+      const currentOffset = page * perPage;
+      const hasMore = currentOffset + perPage < total;
+      if (total === 0) {
+        return {
+          evals: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const dataResult = await this.client.execute({
+        sql: `SELECT * FROM ${TABLE_EVALS} ${whereClause} ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, perPage, currentOffset]
+      });
+      return {
+        evals: dataResult.rows?.map((row) => transformEvalRow(row)) ?? [],
+        total,
+        page,
+        perPage,
+        hasMore
+      };
     } catch (error) {
       throw new MastraError(
         {
-          id: "LIBSQL_STORE_CREATE_TABLE_FAILED",
+          id: "LIBSQL_STORE_GET_EVALS_FAILED",
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
+          category: ErrorCategory.THIRD_PARTY
         },
         error
       );
     }
   }
-  getSqlType(type) {
-    switch (type) {
-      case "bigint":
-        return "INTEGER";
-      // SQLite uses INTEGER for all integer sizes
-      case "jsonb":
-        return "TEXT";
-      // Store JSON as TEXT in SQLite
-      default:
-        return super.getSqlType(type);
+};
+var MemoryLibSQL = class extends MemoryStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  parseRow(row) {
+    let content = row.content;
+    try {
+      content = JSON.parse(row.content);
+    } catch {
     }
+    const result = {
+      id: row.id,
+      content,
+      role: row.role,
+      createdAt: new Date(row.createdAt),
+      threadId: row.thread_id,
+      resourceId: row.resourceId
+    };
+    if (row.type && row.type !== `v2`) result.type = row.type;
+    return result;
   }
-  /**
-   * 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
+  async _getIncludedMessages({
+    threadId,
+    selectBy
+  }) {
+    const include = selectBy?.include;
+    if (!include) return null;
+    const unionQueries = [];
+    const params = [];
+    for (const inc of include) {
+      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+      const searchId = inc.threadId || threadId;
+      unionQueries.push(
+        `
+                SELECT * FROM (
+                  WITH numbered_messages AS (
+                    SELECT
+                      id, content, role, type, "createdAt", thread_id, "resourceId",
+                      ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
+                    FROM "${TABLE_MESSAGES}"
+                    WHERE thread_id = ?
+                  ),
+                  target_positions AS (
+                    SELECT row_num as target_pos
+                    FROM numbered_messages
+                    WHERE id = ?
+                  )
+                  SELECT DISTINCT m.*
+                  FROM numbered_messages m
+                  CROSS JOIN target_positions t
+                  WHERE m.row_num BETWEEN (t.target_pos - ?) AND (t.target_pos + ?)
+                ) 
+                `
+        // Keep ASC for final sorting after fetching context
+      );
+      params.push(searchId, id, withPreviousMessages, withNextMessages);
+    }
+    const finalQuery = unionQueries.join(" UNION ALL ") + ' ORDER BY "createdAt" ASC';
+    const includedResult = await this.client.execute({ sql: finalQuery, args: params });
+    const includedRows = includedResult.rows?.map((row) => this.parseRow(row));
+    const seen = /* @__PURE__ */ new Set();
+    const dedupedRows = includedRows.filter((row) => {
+      if (seen.has(row.id)) return false;
+      seen.add(row.id);
+      return true;
+    });
+    return dedupedRows;
+  }
+  async getMessages({
+    threadId,
+    selectBy,
+    format
   }) {
-    const parsedTableName = parseSqlIdentifier(tableName, "table name");
     try {
-      const pragmaQuery = `PRAGMA table_info(${parsedTableName})`;
-      const result = await this.client.execute(pragmaQuery);
-      const existingColumnNames = new Set(result.rows.map((row) => row.name.toLowerCase()));
-      for (const columnName of ifNotExists) {
-        if (!existingColumnNames.has(columnName.toLowerCase()) && schema[columnName]) {
-          const columnDef = schema[columnName];
-          const sqlType = this.getSqlType(columnDef.type);
-          const nullable = columnDef.nullable === false ? "NOT NULL" : "";
-          const defaultValue = columnDef.nullable === false ? this.getDefaultValue(columnDef.type) : "";
-          const alterSql = `ALTER TABLE ${parsedTableName} ADD COLUMN "${columnName}" ${sqlType} ${nullable} ${defaultValue}`.trim();
-          await this.client.execute(alterSql);
-          this.logger?.debug?.(`Added column ${columnName} to table ${parsedTableName}`);
+      const messages = [];
+      const limit = resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
+      if (selectBy?.include?.length) {
+        const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
+        if (includeMessages) {
+          messages.push(...includeMessages);
         }
       }
+      const excludeIds = messages.map((m) => m.id);
+      const remainingSql = `
+        SELECT 
+          id, 
+          content, 
+          role, 
+          type,
+          "createdAt", 
+          thread_id,
+          "resourceId"
+        FROM "${TABLE_MESSAGES}"
+        WHERE thread_id = ?
+        ${excludeIds.length ? `AND id NOT IN (${excludeIds.map(() => "?").join(", ")})` : ""}
+        ORDER BY "createdAt" DESC
+        LIMIT ?
+      `;
+      const remainingArgs = [threadId, ...excludeIds.length ? excludeIds : [], limit];
+      const remainingResult = await this.client.execute({ sql: remainingSql, args: remainingArgs });
+      if (remainingResult.rows) {
+        messages.push(...remainingResult.rows.map((row) => this.parseRow(row)));
+      }
+      messages.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+      const list = new MessageList().add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
       throw new MastraError(
         {
-          id: "LIBSQL_STORE_ALTER_TABLE_FAILED",
+          id: "LIBSQL_STORE_GET_MESSAGES_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
+          details: { threadId }
         },
         error
       );
     }
   }
-  async clearTable({ tableName }) {
-    const parsedTableName = parseSqlIdentifier(tableName, "table name");
+  async getMessagesPaginated(args) {
+    const { threadId, format, selectBy } = args;
+    const { page = 0, perPage: perPageInput, dateRange } = selectBy?.pagination || {};
+    const perPage = perPageInput !== void 0 ? perPageInput : resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const messages = [];
+    if (selectBy?.include?.length) {
+      try {
+        const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
+        if (includeMessages) {
+          messages.push(...includeMessages);
+        }
+      } catch (error) {
+        throw new MastraError(
+          {
+            id: "LIBSQL_STORE_GET_MESSAGES_PAGINATED_GET_INCLUDE_MESSAGES_FAILED",
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.THIRD_PARTY,
+            details: { threadId }
+          },
+          error
+        );
+      }
+    }
     try {
-      await this.client.execute(`DELETE FROM ${parsedTableName}`);
-    } catch (e) {
+      const currentOffset = page * perPage;
+      const conditions = [`thread_id = ?`];
+      const queryParams = [threadId];
+      if (fromDate) {
+        conditions.push(`"createdAt" >= ?`);
+        queryParams.push(fromDate.toISOString());
+      }
+      if (toDate) {
+        conditions.push(`"createdAt" <= ?`);
+        queryParams.push(toDate.toISOString());
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const countResult = await this.client.execute({
+        sql: `SELECT COUNT(*) as count FROM ${TABLE_MESSAGES} ${whereClause}`,
+        args: queryParams
+      });
+      const total = Number(countResult.rows?.[0]?.count ?? 0);
+      if (total === 0 && messages.length === 0) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const excludeIds = messages.map((m) => m.id);
+      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + queryParams.length + 1}`).join(", ");
+      const dataResult = await this.client.execute({
+        sql: `SELECT id, content, role, type, "createdAt", "resourceId", "thread_id" FROM ${TABLE_MESSAGES} ${whereClause} ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ""} ORDER BY "createdAt" DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, ...excludeIds, perPage, currentOffset]
+      });
+      messages.push(...(dataResult.rows || []).map((row) => this.parseRow(row)));
+      const messagesToReturn = format === "v1" ? new MessageList().add(messages, "memory").get.all.v1() : new MessageList().add(messages, "memory").get.all.v2();
+      return {
+        messages: messagesToReturn,
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + messages.length < total
+      };
+    } catch (error) {
       const mastraError = new MastraError(
         {
-          id: "LIBSQL_STORE_CLEAR_TABLE_FAILED",
+          id: "LIBSQL_STORE_GET_MESSAGES_PAGINATED_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
+          details: { threadId }
         },
-        e
+        error
       );
       this.logger?.trackException?.(mastraError);
       this.logger?.error?.(mastraError.toString());
+      return { messages: [], total: 0, page, perPage, hasMore: false };
     }
   }
-  prepareStatement({ tableName, record }) {
-    const parsedTableName = parseSqlIdentifier(tableName, "table name");
-    const columns = Object.keys(record).map((col) => parseSqlIdentifier(col, "column name"));
-    const values = Object.values(record).map((v) => {
-      if (typeof v === `undefined`) {
-        return null;
-      }
-      if (v instanceof Date) {
-        return v.toISOString();
+  async saveMessages({
+    messages,
+    format
+  }) {
+    if (messages.length === 0) return messages;
+    try {
+      const threadId = messages[0]?.threadId;
+      if (!threadId) {
+        throw new Error("Thread ID is required");
       }
-      return typeof v === "object" ? JSON.stringify(v) : v;
-    });
-    const placeholders = values.map(() => "?").join(", ");
-    return {
-      sql: `INSERT OR REPLACE INTO ${parsedTableName} (${columns.join(", ")}) VALUES (${placeholders})`,
-      args: values
-    };
-  }
-  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...`
+      const batchStatements = messages.map((message) => {
+        const time = message.createdAt || /* @__PURE__ */ new Date();
+        if (!message.threadId) {
+          throw new Error(
+            `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`
           );
-          await new Promise((resolve) => setTimeout(resolve, backoffTime));
-        } else {
-          this.logger.error(`LibSQLStore: Error during ${operationDescription} after ${retries} retries: ${error}`);
-          throw error;
         }
-      }
+        if (!message.resourceId) {
+          throw new Error(
+            `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`
+          );
+        }
+        return {
+          sql: `INSERT INTO ${TABLE_MESSAGES} (id, thread_id, content, role, type, createdAt, resourceId) 
+                  VALUES (?, ?, ?, ?, ?, ?, ?)
+                  ON CONFLICT(id) DO UPDATE SET
+                    thread_id=excluded.thread_id,
+                    content=excluded.content,
+                    role=excluded.role,
+                    type=excluded.type,
+                    resourceId=excluded.resourceId
+                `,
+          args: [
+            message.id,
+            message.threadId,
+            typeof message.content === "object" ? JSON.stringify(message.content) : message.content,
+            message.role,
+            message.type || "v2",
+            time instanceof Date ? time.toISOString() : time,
+            message.resourceId
+          ]
+        };
+      });
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      batchStatements.push({
+        sql: `UPDATE ${TABLE_THREADS} SET updatedAt = ? WHERE id = ?`,
+        args: [now, threadId]
+      });
+      await this.client.batch(batchStatements, "write");
+      const list = new MessageList().add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_SAVE_MESSAGES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
     }
   }
-  insert(args) {
-    return this.executeWriteOperationWithRetry(() => this.doInsert(args), `insert into table ${args.tableName}`);
+  async updateMessages({
+    messages
+  }) {
+    if (messages.length === 0) {
+      return [];
+    }
+    const messageIds = messages.map((m) => m.id);
+    const placeholders = messageIds.map(() => "?").join(",");
+    const selectSql = `SELECT * FROM ${TABLE_MESSAGES} WHERE id IN (${placeholders})`;
+    const existingResult = await this.client.execute({ sql: selectSql, args: messageIds });
+    const existingMessages = existingResult.rows.map((row) => this.parseRow(row));
+    if (existingMessages.length === 0) {
+      return [];
+    }
+    const batchStatements = [];
+    const threadIdsToUpdate = /* @__PURE__ */ new Set();
+    const columnMapping = {
+      threadId: "thread_id"
+    };
+    for (const existingMessage of existingMessages) {
+      const updatePayload = messages.find((m) => m.id === existingMessage.id);
+      if (!updatePayload) continue;
+      const { id, ...fieldsToUpdate } = updatePayload;
+      if (Object.keys(fieldsToUpdate).length === 0) continue;
+      threadIdsToUpdate.add(existingMessage.threadId);
+      if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+        threadIdsToUpdate.add(updatePayload.threadId);
+      }
+      const setClauses = [];
+      const args = [];
+      const updatableFields = { ...fieldsToUpdate };
+      if (updatableFields.content) {
+        const newContent = {
+          ...existingMessage.content,
+          ...updatableFields.content,
+          // Deep merge metadata if it exists on both
+          ...existingMessage.content?.metadata && updatableFields.content.metadata ? {
+            metadata: {
+              ...existingMessage.content.metadata,
+              ...updatableFields.content.metadata
+            }
+          } : {}
+        };
+        setClauses.push(`${parseSqlIdentifier$1("content", "column name")} = ?`);
+        args.push(JSON.stringify(newContent));
+        delete updatableFields.content;
+      }
+      for (const key in updatableFields) {
+        if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+          const dbKey = columnMapping[key] || key;
+          setClauses.push(`${parseSqlIdentifier$1(dbKey, "column name")} = ?`);
+          let value = updatableFields[key];
+          if (typeof value === "object" && value !== null) {
+            value = JSON.stringify(value);
+          }
+          args.push(value);
+        }
+      }
+      if (setClauses.length === 0) continue;
+      args.push(id);
+      const sql = `UPDATE ${TABLE_MESSAGES} SET ${setClauses.join(", ")} WHERE id = ?`;
+      batchStatements.push({ sql, args });
+    }
+    if (batchStatements.length === 0) {
+      return existingMessages;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const threadId of threadIdsToUpdate) {
+      if (threadId) {
+        batchStatements.push({
+          sql: `UPDATE ${TABLE_THREADS} SET updatedAt = ? WHERE id = ?`,
+          args: [now, threadId]
+        });
+      }
+    }
+    await this.client.batch(batchStatements, "write");
+    const updatedResult = await this.client.execute({ sql: selectSql, args: messageIds });
+    return updatedResult.rows.map((row) => this.parseRow(row));
   }
-  async doInsert({
-    tableName,
-    record
-  }) {
-    await this.client.execute(
-      this.prepareStatement({
-        tableName,
-        record
-      })
-    );
+  async getResourceById({ resourceId }) {
+    const result = await this.operations.load({
+      tableName: TABLE_RESOURCES,
+      keys: { id: resourceId }
+    });
+    if (!result) {
+      return null;
+    }
+    return {
+      ...result,
+      // Ensure workingMemory is always returned as a string, even if auto-parsed as JSON
+      workingMemory: result.workingMemory && typeof result.workingMemory === "object" ? JSON.stringify(result.workingMemory) : result.workingMemory,
+      metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata,
+      createdAt: new Date(result.createdAt),
+      updatedAt: new Date(result.updatedAt)
+    };
   }
-  batchInsert(args) {
-    return this.executeWriteOperationWithRetry(
-      () => this.doBatchInsert(args),
-      `batch insert into table ${args.tableName}`
-    ).catch((error) => {
-      throw new MastraError(
-        {
-          id: "LIBSQL_STORE_BATCH_INSERT_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName: args.tableName
-          }
-        },
-        error
-      );
+  async saveResource({ resource }) {
+    console.log("resource", resource);
+    await this.operations.insert({
+      tableName: TABLE_RESOURCES,
+      record: {
+        ...resource,
+        metadata: JSON.stringify(resource.metadata)
+      }
     });
+    return resource;
   }
-  async doBatchInsert({
-    tableName,
-    records
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
   }) {
-    if (records.length === 0) return;
-    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");
-    const parsedKeys = Object.keys(keys).map((key) => parseSqlIdentifier(key, "column name"));
-    const conditions = parsedKeys.map((key) => `${key} = ?`).join(" AND ");
-    const values = Object.values(keys);
-    const result = await this.client.execute({
-      sql: `SELECT * FROM ${parsedTableName} WHERE ${conditions} ORDER BY createdAt DESC LIMIT 1`,
+    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 updates = [];
+    const values = [];
+    if (workingMemory !== void 0) {
+      updates.push("workingMemory = ?");
+      values.push(workingMemory);
+    }
+    if (metadata) {
+      updates.push("metadata = ?");
+      values.push(JSON.stringify(updatedResource.metadata));
+    }
+    updates.push("updatedAt = ?");
+    values.push(updatedResource.updatedAt.toISOString());
+    values.push(resourceId);
+    await this.client.execute({
+      sql: `UPDATE ${TABLE_RESOURCES} SET ${updates.join(", ")} WHERE id = ?`,
       args: values
     });
-    if (!result.rows || result.rows.length === 0) {
-      return null;
-    }
-    const row = result.rows[0];
-    const parsed = Object.fromEntries(
-      Object.entries(row || {}).map(([k, v]) => {
-        try {
-          return [k, typeof v === "string" ? v.startsWith("{") || v.startsWith("[") ? JSON.parse(v) : v : v];
-        } catch {
-          return [k, v];
-        }
-      })
-    );
-    return parsed;
+    return updatedResource;
   }
   async getThreadById({ threadId }) {
     try {
-      const result = await this.load({
+      const result = await this.operations.load({
         tableName: TABLE_THREADS,
         keys: { id: threadId }
       });
@@ -1162,7 +1449,9 @@ var LibSQLStore = class extends MastraStorage {
       }
       return {
         ...result,
-        metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
+        metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata,
+        createdAt: new Date(result.createdAt),
+        updatedAt: new Date(result.updatedAt)
       };
     } catch (error) {
       throw new MastraError(
@@ -1276,7 +1565,7 @@ var LibSQLStore = class extends MastraStorage {
   }
   async saveThread({ thread }) {
     try {
-      await this.insert({
+      await this.operations.insert({
         tableName: TABLE_THREADS,
         record: {
           ...thread,
@@ -1311,7 +1600,10 @@ var LibSQLStore = class extends MastraStorage {
         domain: ErrorDomain.STORAGE,
         category: ErrorCategory.USER,
         text: `Thread ${id} not found`,
-        details: { threadId: id }
+        details: {
+          status: 404,
+          threadId: id
+        }
       });
     }
     const updatedThread = {
@@ -1354,268 +1646,329 @@ var LibSQLStore = class extends MastraStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "LIBSQL_STORE_DELETE_THREAD_FAILED",
+          id: "LIBSQL_STORE_DELETE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error
+      );
+    }
+  }
+};
+function createExecuteWriteOperationWithRetry({
+  logger,
+  maxRetries,
+  initialBackoffMs
+}) {
+  return async function 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 < maxRetries) {
+          retries++;
+          const backoffTime = initialBackoffMs * Math.pow(2, retries - 1);
+          logger.warn(
+            `LibSQLStore: Encountered SQLITE_BUSY during ${operationDescription}. Retrying (${retries}/${maxRetries}) in ${backoffTime}ms...`
+          );
+          await new Promise((resolve) => setTimeout(resolve, backoffTime));
+        } else {
+          logger.error(`LibSQLStore: Error during ${operationDescription} after ${retries} retries: ${error}`);
+          throw error;
+        }
+      }
+    }
+  };
+}
+function prepareStatement({ tableName, record }) {
+  const parsedTableName = parseSqlIdentifier(tableName, "table name");
+  const columns = Object.keys(record).map((col) => parseSqlIdentifier(col, "column name"));
+  const values = Object.values(record).map((v) => {
+    if (typeof v === `undefined`) {
+      return null;
+    }
+    if (v instanceof Date) {
+      return v.toISOString();
+    }
+    return typeof v === "object" ? JSON.stringify(v) : v;
+  });
+  const placeholders = values.map(() => "?").join(", ");
+  return {
+    sql: `INSERT OR REPLACE INTO ${parsedTableName} (${columns.join(", ")}) VALUES (${placeholders})`,
+    args: values
+  };
+}
+
+// src/storage/domains/operations/index.ts
+var StoreOperationsLibSQL = class extends StoreOperations {
+  client;
+  /**
+   * Maximum number of retries for write operations if an SQLITE_BUSY error occurs.
+   * @default 5
+   */
+  maxRetries;
+  /**
+   * 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;
+  constructor({
+    client,
+    maxRetries,
+    initialBackoffMs
+  }) {
+    super();
+    this.client = client;
+    this.maxRetries = maxRetries ?? 5;
+    this.initialBackoffMs = initialBackoffMs ?? 100;
+  }
+  async hasColumn(table, column) {
+    const result = await this.client.execute({
+      sql: `PRAGMA table_info(${table})`
+    });
+    return (await result.rows)?.some((row) => row.name === column);
+  }
+  getCreateTableSQL(tableName, schema) {
+    const parsedTableName = parseSqlIdentifier(tableName, "table name");
+    const columns = Object.entries(schema).map(([name, col]) => {
+      const parsedColumnName = parseSqlIdentifier(name, "column name");
+      let type = col.type.toUpperCase();
+      if (type === "TEXT") type = "TEXT";
+      if (type === "TIMESTAMP") type = "TEXT";
+      const nullable = col.nullable ? "" : "NOT NULL";
+      const primaryKey = col.primaryKey ? "PRIMARY KEY" : "";
+      return `${parsedColumnName} ${type} ${nullable} ${primaryKey}`.trim();
+    });
+    if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
+      const stmnt = `CREATE TABLE IF NOT EXISTS ${parsedTableName} (
+                    ${columns.join(",\n")},
+                    PRIMARY KEY (workflow_name, run_id)
+                )`;
+      return stmnt;
+    }
+    return `CREATE TABLE IF NOT EXISTS ${parsedTableName} (${columns.join(", ")})`;
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    try {
+      this.logger.debug(`Creating database table`, { tableName, operation: "schema init" });
+      const sql = this.getCreateTableSQL(tableName, schema);
+      await this.client.execute(sql);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_CREATE_TABLE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error
+      );
+    }
+  }
+  getSqlType(type) {
+    switch (type) {
+      case "bigint":
+        return "INTEGER";
+      // SQLite uses INTEGER for all integer sizes
+      case "jsonb":
+        return "TEXT";
+      // Store JSON as TEXT in SQLite
+      default:
+        return super.getSqlType(type);
+    }
+  }
+  async doInsert({
+    tableName,
+    record
+  }) {
+    await this.client.execute(
+      prepareStatement({
+        tableName,
+        record
+      })
+    );
+  }
+  insert(args) {
+    const executeWriteOperationWithRetry = createExecuteWriteOperationWithRetry({
+      logger: this.logger,
+      maxRetries: this.maxRetries,
+      initialBackoffMs: this.initialBackoffMs
+    });
+    return executeWriteOperationWithRetry(() => this.doInsert(args), `insert into table ${args.tableName}`);
+  }
+  async load({ tableName, keys }) {
+    const parsedTableName = parseSqlIdentifier(tableName, "table name");
+    const parsedKeys = Object.keys(keys).map((key) => parseSqlIdentifier(key, "column name"));
+    const conditions = parsedKeys.map((key) => `${key} = ?`).join(" AND ");
+    const values = Object.values(keys);
+    const result = await this.client.execute({
+      sql: `SELECT * FROM ${parsedTableName} WHERE ${conditions} ORDER BY createdAt DESC LIMIT 1`,
+      args: values
+    });
+    if (!result.rows || result.rows.length === 0) {
+      return null;
+    }
+    const row = result.rows[0];
+    const parsed = Object.fromEntries(
+      Object.entries(row || {}).map(([k, v]) => {
+        try {
+          return [k, typeof v === "string" ? v.startsWith("{") || v.startsWith("[") ? JSON.parse(v) : v : v];
+        } catch {
+          return [k, v];
+        }
+      })
+    );
+    return parsed;
+  }
+  async doBatchInsert({
+    tableName,
+    records
+  }) {
+    if (records.length === 0) return;
+    const batchStatements = records.map((r) => prepareStatement({ tableName, record: r }));
+    await this.client.batch(batchStatements, "write");
+  }
+  batchInsert(args) {
+    const executeWriteOperationWithRetry = createExecuteWriteOperationWithRetry({
+      logger: this.logger,
+      maxRetries: this.maxRetries,
+      initialBackoffMs: this.initialBackoffMs
+    });
+    return executeWriteOperationWithRetry(
+      () => this.doBatchInsert(args),
+      `batch insert into table ${args.tableName}`
+    ).catch((error) => {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_BATCH_INSERT_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: {
+            tableName: args.tableName
+          }
         },
         error
       );
-    }
-  }
-  parseRow(row) {
-    let content = row.content;
-    try {
-      content = JSON.parse(row.content);
-    } catch {
-    }
-    const result = {
-      id: row.id,
-      content,
-      role: row.role,
-      createdAt: new Date(row.createdAt),
-      threadId: row.thread_id,
-      resourceId: row.resourceId
-    };
-    if (row.type && row.type !== `v2`) result.type = row.type;
-    return result;
-  }
-  async _getIncludedMessages({
-    threadId,
-    selectBy
-  }) {
-    const include = selectBy?.include;
-    if (!include) return null;
-    const unionQueries = [];
-    const params = [];
-    for (const inc of include) {
-      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
-      const searchId = inc.threadId || threadId;
-      unionQueries.push(
-        `
-            SELECT * FROM (
-              WITH numbered_messages AS (
-                SELECT
-                  id, content, role, type, "createdAt", thread_id, "resourceId",
-                  ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
-                FROM "${TABLE_MESSAGES}"
-                WHERE thread_id = ?
-              ),
-              target_positions AS (
-                SELECT row_num as target_pos
-                FROM numbered_messages
-                WHERE id = ?
-              )
-              SELECT DISTINCT m.*
-              FROM numbered_messages m
-              CROSS JOIN target_positions t
-              WHERE m.row_num BETWEEN (t.target_pos - ?) AND (t.target_pos + ?)
-            ) 
-            `
-        // Keep ASC for final sorting after fetching context
-      );
-      params.push(searchId, id, withPreviousMessages, withNextMessages);
-    }
-    const finalQuery = unionQueries.join(" UNION ALL ") + ' ORDER BY "createdAt" ASC';
-    const includedResult = await this.client.execute({ sql: finalQuery, args: params });
-    const includedRows = includedResult.rows?.map((row) => this.parseRow(row));
-    const seen = /* @__PURE__ */ new Set();
-    const dedupedRows = includedRows.filter((row) => {
-      if (seen.has(row.id)) return false;
-      seen.add(row.id);
-      return true;
     });
-    return dedupedRows;
   }
-  async getMessages({
-    threadId,
-    selectBy,
-    format
+  /**
+   * Alters table schema to add columns if they don't exist
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists
   }) {
+    const parsedTableName = parseSqlIdentifier(tableName, "table name");
     try {
-      const messages = [];
-      const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
-      if (selectBy?.include?.length) {
-        const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
-        if (includeMessages) {
-          messages.push(...includeMessages);
+      const pragmaQuery = `PRAGMA table_info(${parsedTableName})`;
+      const result = await this.client.execute(pragmaQuery);
+      const existingColumnNames = new Set(result.rows.map((row) => row.name.toLowerCase()));
+      for (const columnName of ifNotExists) {
+        if (!existingColumnNames.has(columnName.toLowerCase()) && schema[columnName]) {
+          const columnDef = schema[columnName];
+          const sqlType = this.getSqlType(columnDef.type);
+          const nullable = columnDef.nullable === false ? "NOT NULL" : "";
+          const defaultValue = columnDef.nullable === false ? this.getDefaultValue(columnDef.type) : "";
+          const alterSql = `ALTER TABLE ${parsedTableName} ADD COLUMN "${columnName}" ${sqlType} ${nullable} ${defaultValue}`.trim();
+          await this.client.execute(alterSql);
+          this.logger?.debug?.(`Added column ${columnName} to table ${parsedTableName}`);
         }
       }
-      const excludeIds = messages.map((m) => m.id);
-      const remainingSql = `
-        SELECT 
-          id, 
-          content, 
-          role, 
-          type,
-          "createdAt", 
-          thread_id,
-          "resourceId"
-        FROM "${TABLE_MESSAGES}"
-        WHERE thread_id = ?
-        ${excludeIds.length ? `AND id NOT IN (${excludeIds.map(() => "?").join(", ")})` : ""}
-        ORDER BY "createdAt" DESC
-        LIMIT ?
-      `;
-      const remainingArgs = [threadId, ...excludeIds.length ? excludeIds : [], limit];
-      const remainingResult = await this.client.execute({ sql: remainingSql, args: remainingArgs });
-      if (remainingResult.rows) {
-        messages.push(...remainingResult.rows.map((row) => this.parseRow(row)));
-      }
-      messages.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-      const list = new MessageList().add(messages, "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
     } catch (error) {
       throw new MastraError(
         {
-          id: "LIBSQL_STORE_GET_MESSAGES_FAILED",
+          id: "LIBSQL_STORE_ALTER_TABLE_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: {
+            tableName
+          }
         },
         error
       );
     }
   }
-  async getMessagesPaginated(args) {
-    const { threadId, format, selectBy } = args;
-    const { page = 0, perPage: perPageInput, dateRange } = selectBy?.pagination || {};
-    const perPage = perPageInput !== void 0 ? perPageInput : this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-    const messages = [];
-    if (selectBy?.include?.length) {
-      try {
-        const includeMessages = await this._getIncludedMessages({ threadId, selectBy });
-        if (includeMessages) {
-          messages.push(...includeMessages);
-        }
-      } catch (error) {
-        throw new MastraError(
-          {
-            id: "LIBSQL_STORE_GET_MESSAGES_PAGINATED_GET_INCLUDE_MESSAGES_FAILED",
-            domain: ErrorDomain.STORAGE,
-            category: ErrorCategory.THIRD_PARTY,
-            details: { threadId }
-          },
-          error
-        );
-      }
-    }
+  async clearTable({ tableName }) {
+    const parsedTableName = parseSqlIdentifier(tableName, "table name");
     try {
-      const currentOffset = page * perPage;
-      const conditions = [`thread_id = ?`];
-      const queryParams = [threadId];
-      if (fromDate) {
-        conditions.push(`"createdAt" >= ?`);
-        queryParams.push(fromDate.toISOString());
-      }
-      if (toDate) {
-        conditions.push(`"createdAt" <= ?`);
-        queryParams.push(toDate.toISOString());
-      }
-      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-      const countResult = await this.client.execute({
-        sql: `SELECT COUNT(*) as count FROM ${TABLE_MESSAGES} ${whereClause}`,
-        args: queryParams
-      });
-      const total = Number(countResult.rows?.[0]?.count ?? 0);
-      if (total === 0 && messages.length === 0) {
-        return {
-          messages: [],
-          total: 0,
-          page,
-          perPage,
-          hasMore: false
-        };
-      }
-      const excludeIds = messages.map((m) => m.id);
-      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + queryParams.length + 1}`).join(", ");
-      const dataResult = await this.client.execute({
-        sql: `SELECT id, content, role, type, "createdAt", "resourceId", "thread_id" FROM ${TABLE_MESSAGES} ${whereClause} ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ""} ORDER BY "createdAt" DESC LIMIT ? OFFSET ?`,
-        args: [...queryParams, ...excludeIds, perPage, currentOffset]
-      });
-      messages.push(...(dataResult.rows || []).map((row) => this.parseRow(row)));
-      const messagesToReturn = format === "v1" ? new MessageList().add(messages, "memory").get.all.v1() : new MessageList().add(messages, "memory").get.all.v2();
-      return {
-        messages: messagesToReturn,
-        total,
-        page,
-        perPage,
-        hasMore: currentOffset + messages.length < total
-      };
-    } catch (error) {
+      await this.client.execute(`DELETE FROM ${parsedTableName}`);
+    } catch (e) {
       const mastraError = new MastraError(
         {
-          id: "LIBSQL_STORE_GET_MESSAGES_PAGINATED_FAILED",
+          id: "LIBSQL_STORE_CLEAR_TABLE_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: {
+            tableName
+          }
         },
-        error
+        e
       );
       this.logger?.trackException?.(mastraError);
       this.logger?.error?.(mastraError.toString());
-      return { messages: [], total: 0, page, perPage, hasMore: false };
     }
   }
-  async saveMessages({
-    messages,
-    format
-  }) {
-    if (messages.length === 0) return messages;
+  async dropTable({ tableName }) {
+    const parsedTableName = parseSqlIdentifier(tableName, "table name");
     try {
-      const threadId = messages[0]?.threadId;
-      if (!threadId) {
-        throw new Error("Thread ID is required");
-      }
-      const batchStatements = messages.map((message) => {
-        const time = message.createdAt || /* @__PURE__ */ new Date();
-        if (!message.threadId) {
-          throw new Error(
-            `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`
-          );
-        }
-        if (!message.resourceId) {
-          throw new Error(
-            `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`
-          );
-        }
-        return {
-          sql: `INSERT INTO ${TABLE_MESSAGES} (id, thread_id, content, role, type, createdAt, resourceId) 
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-                ON CONFLICT(id) DO UPDATE SET
-                  thread_id=excluded.thread_id,
-                  content=excluded.content,
-                  role=excluded.role,
-                  type=excluded.type,
-                  resourceId=excluded.resourceId
-              `,
-          args: [
-            message.id,
-            message.threadId,
-            typeof message.content === "object" ? JSON.stringify(message.content) : message.content,
-            message.role,
-            message.type || "v2",
-            time instanceof Date ? time.toISOString() : time,
-            message.resourceId
-          ]
-        };
-      });
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      batchStatements.push({
-        sql: `UPDATE ${TABLE_THREADS} SET updatedAt = ? WHERE id = ?`,
-        args: [now, threadId]
+      await this.client.execute(`DROP TABLE IF EXISTS ${parsedTableName}`);
+    } catch (e) {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_DROP_TABLE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        e
+      );
+    }
+  }
+};
+var ScoresLibSQL = class extends ScoresStorage {
+  operations;
+  client;
+  constructor({ client, operations }) {
+    super();
+    this.operations = operations;
+    this.client = client;
+  }
+  async getScoresByRunId({
+    runId,
+    pagination
+  }) {
+    try {
+      const result = await this.client.execute({
+        sql: `SELECT * FROM ${TABLE_SCORERS} WHERE runId = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        args: [runId, pagination.perPage + 1, pagination.page * pagination.perPage]
       });
-      await this.client.batch(batchStatements, "write");
-      const list = new MessageList().add(messages, "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
+      return {
+        scores: result.rows?.slice(0, pagination.perPage).map((row) => this.transformScoreRow(row)) ?? [],
+        pagination: {
+          total: result.rows?.length ?? 0,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: result.rows?.length > pagination.perPage
+        }
+      };
     } catch (error) {
       throw new MastraError(
         {
-          id: "LIBSQL_STORE_SAVE_MESSAGES_FAILED",
+          id: "LIBSQL_STORE_GET_SCORES_BY_RUN_ID_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY
         },
@@ -1623,185 +1976,144 @@ var LibSQLStore = class extends MastraStorage {
       );
     }
   }
-  async updateMessages({
-    messages
+  async getScoresByScorerId({
+    scorerId,
+    entityId,
+    entityType,
+    pagination
   }) {
-    if (messages.length === 0) {
-      return [];
-    }
-    const messageIds = messages.map((m) => m.id);
-    const placeholders = messageIds.map(() => "?").join(",");
-    const selectSql = `SELECT * FROM ${TABLE_MESSAGES} WHERE id IN (${placeholders})`;
-    const existingResult = await this.client.execute({ sql: selectSql, args: messageIds });
-    const existingMessages = existingResult.rows.map((row) => this.parseRow(row));
-    if (existingMessages.length === 0) {
-      return [];
-    }
-    const batchStatements = [];
-    const threadIdsToUpdate = /* @__PURE__ */ new Set();
-    const columnMapping = {
-      threadId: "thread_id"
-    };
-    for (const existingMessage of existingMessages) {
-      const updatePayload = messages.find((m) => m.id === existingMessage.id);
-      if (!updatePayload) continue;
-      const { id, ...fieldsToUpdate } = updatePayload;
-      if (Object.keys(fieldsToUpdate).length === 0) continue;
-      threadIdsToUpdate.add(existingMessage.threadId);
-      if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
-        threadIdsToUpdate.add(updatePayload.threadId);
-      }
-      const setClauses = [];
-      const args = [];
-      const updatableFields = { ...fieldsToUpdate };
-      if (updatableFields.content) {
-        const newContent = {
-          ...existingMessage.content,
-          ...updatableFields.content,
-          // Deep merge metadata if it exists on both
-          ...existingMessage.content?.metadata && updatableFields.content.metadata ? {
-            metadata: {
-              ...existingMessage.content.metadata,
-              ...updatableFields.content.metadata
-            }
-          } : {}
-        };
-        setClauses.push(`${parseSqlIdentifier("content", "column name")} = ?`);
-        args.push(JSON.stringify(newContent));
-        delete updatableFields.content;
+    try {
+      const conditions = [];
+      const queryParams = [];
+      if (scorerId) {
+        conditions.push(`scorerId = ?`);
+        queryParams.push(scorerId);
       }
-      for (const key in updatableFields) {
-        if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
-          const dbKey = columnMapping[key] || key;
-          setClauses.push(`${parseSqlIdentifier(dbKey, "column name")} = ?`);
-          let value = updatableFields[key];
-          if (typeof value === "object" && value !== null) {
-            value = JSON.stringify(value);
-          }
-          args.push(value);
-        }
+      if (entityId) {
+        conditions.push(`entityId = ?`);
+        queryParams.push(entityId);
       }
-      if (setClauses.length === 0) continue;
-      args.push(id);
-      const sql = `UPDATE ${TABLE_MESSAGES} SET ${setClauses.join(", ")} WHERE id = ?`;
-      batchStatements.push({ sql, args });
-    }
-    if (batchStatements.length === 0) {
-      return existingMessages;
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    for (const threadId of threadIdsToUpdate) {
-      if (threadId) {
-        batchStatements.push({
-          sql: `UPDATE ${TABLE_THREADS} SET updatedAt = ? WHERE id = ?`,
-          args: [now, threadId]
-        });
+      if (entityType) {
+        conditions.push(`entityType = ?`);
+        queryParams.push(entityType);
       }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const result = await this.client.execute({
+        sql: `SELECT * FROM ${TABLE_SCORERS} ${whereClause} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, pagination.perPage + 1, pagination.page * pagination.perPage]
+      });
+      return {
+        scores: result.rows?.slice(0, pagination.perPage).map((row) => this.transformScoreRow(row)) ?? [],
+        pagination: {
+          total: result.rows?.length ?? 0,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: result.rows?.length > pagination.perPage
+        }
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_GET_SCORES_BY_SCORER_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
     }
-    await this.client.batch(batchStatements, "write");
-    const updatedResult = await this.client.execute({ sql: selectSql, args: messageIds });
-    return updatedResult.rows.map((row) => this.parseRow(row));
   }
-  transformEvalRow(row) {
-    const resultValue = JSON.parse(row.result);
-    const testInfoValue = row.test_info ? JSON.parse(row.test_info) : void 0;
-    if (!resultValue || typeof resultValue !== "object" || !("score" in resultValue)) {
-      throw new Error(`Invalid MetricResult format: ${JSON.stringify(resultValue)}`);
-    }
+  transformScoreRow(row) {
+    const scorerValue = JSON.parse(row.scorer ?? "{}");
+    const inputValue = JSON.parse(row.input ?? "{}");
+    const outputValue = JSON.parse(row.output ?? "{}");
+    const additionalLLMContextValue = row.additionalLLMContext ? JSON.parse(row.additionalLLMContext) : null;
+    const runtimeContextValue = row.runtimeContext ? JSON.parse(row.runtimeContext) : null;
+    const metadataValue = row.metadata ? JSON.parse(row.metadata) : null;
+    const entityValue = row.entity ? JSON.parse(row.entity) : null;
+    const extractStepResultValue = row.extractStepResult ? JSON.parse(row.extractStepResult) : null;
+    const analyzeStepResultValue = row.analyzeStepResult ? JSON.parse(row.analyzeStepResult) : null;
     return {
-      input: row.input,
-      output: row.output,
-      result: resultValue,
-      agentName: row.agent_name,
-      metricName: row.metric_name,
-      instructions: row.instructions,
-      testInfo: testInfoValue,
-      globalRunId: row.global_run_id,
-      runId: row.run_id,
-      createdAt: row.created_at
+      id: row.id,
+      traceId: row.traceId,
+      runId: row.runId,
+      scorer: scorerValue,
+      score: row.score,
+      reason: row.reason,
+      extractStepResult: extractStepResultValue,
+      analyzeStepResult: analyzeStepResultValue,
+      analyzePrompt: row.analyzePrompt,
+      extractPrompt: row.extractPrompt,
+      metadata: metadataValue,
+      input: inputValue,
+      output: outputValue,
+      additionalContext: additionalLLMContextValue,
+      runtimeContext: runtimeContextValue,
+      entityType: row.entityType,
+      entity: entityValue,
+      entityId: row.entityId,
+      scorerId: row.scorerId,
+      source: row.source,
+      resourceId: row.resourceId,
+      threadId: row.threadId,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
     };
   }
-  /** @deprecated use getEvals instead */
-  async getEvalsByAgentName(agentName, type) {
+  async getScoreById({ id }) {
+    const result = await this.client.execute({
+      sql: `SELECT * FROM ${TABLE_SCORERS} WHERE id = ?`,
+      args: [id]
+    });
+    return result.rows?.[0] ? this.transformScoreRow(result.rows[0]) : null;
+  }
+  async saveScore(score) {
     try {
-      const baseQuery = `SELECT * FROM ${TABLE_EVALS} WHERE agent_name = ?`;
-      const typeCondition = type === "test" ? " AND test_info IS NOT NULL AND test_info->>'testPath' IS NOT NULL" : type === "live" ? " AND (test_info IS NULL OR test_info->>'testPath' IS NULL)" : "";
-      const result = await this.client.execute({
-        sql: `${baseQuery}${typeCondition} ORDER BY created_at DESC`,
-        args: [agentName]
+      const id = crypto.randomUUID();
+      await this.operations.insert({
+        tableName: TABLE_SCORERS,
+        record: {
+          id,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          ...score
+        }
       });
-      return result.rows?.map((row) => this.transformEvalRow(row)) ?? [];
+      const scoreFromDb = await this.getScoreById({ id });
+      return { score: scoreFromDb };
     } catch (error) {
-      if (error instanceof Error && error.message.includes("no such table")) {
-        return [];
-      }
       throw new MastraError(
         {
-          id: "LIBSQL_STORE_GET_EVALS_BY_AGENT_NAME_FAILED",
+          id: "LIBSQL_STORE_SAVE_SCORE_FAILED",
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { agentName }
+          category: ErrorCategory.THIRD_PARTY
         },
         error
       );
     }
   }
-  async getEvals(options = {}) {
-    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-    const conditions = [];
-    const queryParams = [];
-    if (agentName) {
-      conditions.push(`agent_name = ?`);
-      queryParams.push(agentName);
-    }
-    if (type === "test") {
-      conditions.push(`(test_info IS NOT NULL AND json_extract(test_info, '$.testPath') IS NOT NULL)`);
-    } else if (type === "live") {
-      conditions.push(`(test_info IS NULL OR json_extract(test_info, '$.testPath') IS NULL)`);
-    }
-    if (fromDate) {
-      conditions.push(`created_at >= ?`);
-      queryParams.push(fromDate.toISOString());
-    }
-    if (toDate) {
-      conditions.push(`created_at <= ?`);
-      queryParams.push(toDate.toISOString());
-    }
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
     try {
-      const countResult = await this.client.execute({
-        sql: `SELECT COUNT(*) as count FROM ${TABLE_EVALS} ${whereClause}`,
-        args: queryParams
-      });
-      const total = Number(countResult.rows?.[0]?.count ?? 0);
-      const currentOffset = page * perPage;
-      const hasMore = currentOffset + perPage < total;
-      if (total === 0) {
-        return {
-          evals: [],
-          total: 0,
-          page,
-          perPage,
-          hasMore: false
-        };
-      }
-      const dataResult = await this.client.execute({
-        sql: `SELECT * FROM ${TABLE_EVALS} ${whereClause} ORDER BY created_at DESC LIMIT ? OFFSET ?`,
-        args: [...queryParams, perPage, currentOffset]
+      const result = await this.client.execute({
+        sql: `SELECT * FROM ${TABLE_SCORERS} WHERE entityId = ? AND entityType = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        args: [entityId, entityType, pagination.perPage + 1, pagination.page * pagination.perPage]
       });
       return {
-        evals: dataResult.rows?.map((row) => this.transformEvalRow(row)) ?? [],
-        total,
-        page,
-        perPage,
-        hasMore
+        scores: result.rows?.slice(0, pagination.perPage).map((row) => this.transformScoreRow(row)) ?? [],
+        pagination: {
+          total: result.rows?.length ?? 0,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: result.rows?.length > pagination.perPage
+        }
       };
     } catch (error) {
       throw new MastraError(
         {
-          id: "LIBSQL_STORE_GET_EVALS_FAILED",
+          id: "LIBSQL_STORE_GET_SCORES_BY_ENTITY_ID_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY
         },
@@ -1809,9 +2121,15 @@ var LibSQLStore = class extends MastraStorage {
       );
     }
   }
-  /**
-   * @deprecated use getTracesPaginated instead.
-   */
+};
+var TracesLibSQL = class extends TracesStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
   async getTraces(args) {
     if (args.fromDate || args.toDate) {
       args.dateRange = {
@@ -1888,35 +2206,133 @@ var LibSQLStore = class extends MastraStorage {
         sql: `SELECT * FROM ${TABLE_TRACES} ${whereClause} ORDER BY "startTime" DESC LIMIT ? OFFSET ?`,
         args: [...queryArgs, perPage, currentOffset]
       });
-      const traces = dataResult.rows?.map(
-        (row) => ({
-          id: row.id,
-          parentSpanId: row.parentSpanId,
-          traceId: row.traceId,
-          name: row.name,
-          scope: row.scope,
-          kind: row.kind,
-          status: safelyParseJSON(row.status),
-          events: safelyParseJSON(row.events),
-          links: safelyParseJSON(row.links),
-          attributes: safelyParseJSON(row.attributes),
-          startTime: row.startTime,
-          endTime: row.endTime,
-          other: safelyParseJSON(row.other),
-          createdAt: row.createdAt
-        })
-      ) ?? [];
-      return {
-        traces,
-        total,
-        page,
-        perPage,
-        hasMore: currentOffset + traces.length < total
-      };
+      const traces = dataResult.rows?.map(
+        (row) => ({
+          id: row.id,
+          parentSpanId: row.parentSpanId,
+          traceId: row.traceId,
+          name: row.name,
+          scope: row.scope,
+          kind: row.kind,
+          status: safelyParseJSON(row.status),
+          events: safelyParseJSON(row.events),
+          links: safelyParseJSON(row.links),
+          attributes: safelyParseJSON(row.attributes),
+          startTime: row.startTime,
+          endTime: row.endTime,
+          other: safelyParseJSON(row.other),
+          createdAt: row.createdAt
+        })
+      ) ?? [];
+      return {
+        traces,
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + traces.length < total
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "LIBSQL_STORE_GET_TRACES_PAGINATED_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
+  async batchTraceInsert({ records }) {
+    this.logger.debug("Batch inserting traces", { count: records.length });
+    await this.operations.batchInsert({
+      tableName: TABLE_TRACES,
+      records
+    });
+  }
+};
+function parseWorkflowRun(row) {
+  let parsedSnapshot = row.snapshot;
+  if (typeof parsedSnapshot === "string") {
+    try {
+      parsedSnapshot = JSON.parse(row.snapshot);
+    } catch (e) {
+      console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+    }
+  }
+  return {
+    workflowName: row.workflow_name,
+    runId: row.run_id,
+    snapshot: parsedSnapshot,
+    resourceId: row.resourceId,
+    createdAt: new Date(row.createdAt),
+    updatedAt: new Date(row.updatedAt)
+  };
+}
+var WorkflowsLibSQL = class extends WorkflowsStorage {
+  operations;
+  client;
+  constructor({ operations, client }) {
+    super();
+    this.operations = operations;
+    this.client = client;
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    const data = {
+      workflow_name: workflowName,
+      run_id: runId,
+      snapshot,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.logger.debug("Persisting workflow snapshot", { workflowName, runId, data });
+    await this.operations.insert({
+      tableName: TABLE_WORKFLOW_SNAPSHOT,
+      record: data
+    });
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    this.logger.debug("Loading workflow snapshot", { workflowName, runId });
+    const d = await this.operations.load({
+      tableName: TABLE_WORKFLOW_SNAPSHOT,
+      keys: { workflow_name: workflowName, run_id: runId }
+    });
+    return d ? d.snapshot : null;
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    const conditions = [];
+    const args = [];
+    if (runId) {
+      conditions.push("run_id = ?");
+      args.push(runId);
+    }
+    if (workflowName) {
+      conditions.push("workflow_name = ?");
+      args.push(workflowName);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    try {
+      const result = await this.client.execute({
+        sql: `SELECT * FROM ${TABLE_WORKFLOW_SNAPSHOT} ${whereClause}`,
+        args
+      });
+      if (!result.rows?.[0]) {
+        return null;
+      }
+      return parseWorkflowRun(result.rows[0]);
     } catch (error) {
       throw new MastraError(
         {
-          id: "LIBSQL_STORE_GET_TRACES_PAGINATED_FAILED",
+          id: "LIBSQL_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY
         },
@@ -1948,7 +2364,7 @@ var LibSQLStore = class extends MastraStorage {
         args.push(toDate.toISOString());
       }
       if (resourceId) {
-        const hasResourceId = await this.hasColumn(TABLE_WORKFLOW_SNAPSHOT, "resourceId");
+        const hasResourceId = await this.operations.hasColumn(TABLE_WORKFLOW_SNAPSHOT, "resourceId");
         if (hasResourceId) {
           conditions.push("resourceId = ?");
           args.push(resourceId);
@@ -1969,7 +2385,7 @@ var LibSQLStore = class extends MastraStorage {
         sql: `SELECT * FROM ${TABLE_WORKFLOW_SNAPSHOT} ${whereClause} ORDER BY createdAt DESC${limit !== void 0 && offset !== void 0 ? ` LIMIT ? OFFSET ?` : ""}`,
         args: limit !== void 0 && offset !== void 0 ? [...args, limit, offset] : args
       });
-      const runs = (result.rows || []).map((row) => this.parseWorkflowRun(row));
+      const runs = (result.rows || []).map((row) => parseWorkflowRun(row));
       return { runs, total: total || runs.length };
     } catch (error) {
       throw new MastraError(
@@ -1982,133 +2398,227 @@ var LibSQLStore = class extends MastraStorage {
       );
     }
   }
+};
+
+// src/storage/index.ts
+var LibSQLStore = class extends MastraStorage {
+  client;
+  maxRetries;
+  initialBackoffMs;
+  stores;
+  constructor(config) {
+    super({ name: `LibSQLStore` });
+    this.maxRetries = config.maxRetries ?? 5;
+    this.initialBackoffMs = config.initialBackoffMs ?? 100;
+    if ("url" in config) {
+      if (config.url.endsWith(":memory:")) {
+        this.shouldCacheInit = false;
+      }
+      this.client = createClient({ url: config.url });
+      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));
+      }
+    } else {
+      this.client = config.client;
+    }
+    const operations = new StoreOperationsLibSQL({
+      client: this.client,
+      maxRetries: this.maxRetries,
+      initialBackoffMs: this.initialBackoffMs
+    });
+    const scores = new ScoresLibSQL({ client: this.client, operations });
+    const traces = new TracesLibSQL({ client: this.client, operations });
+    const workflows = new WorkflowsLibSQL({ client: this.client, operations });
+    const memory = new MemoryLibSQL({ client: this.client, operations });
+    const legacyEvals = new LegacyEvalsLibSQL({ client: this.client });
+    this.stores = {
+      operations,
+      scores,
+      traces,
+      workflows,
+      memory,
+      legacyEvals
+    };
+  }
+  get supports() {
+    return {
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: true,
+      createTable: true
+    };
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    await this.stores.operations.createTable({ tableName, schema });
+  }
+  /**
+   * 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
+  }) {
+    await this.stores.operations.alterTable({ tableName, schema, ifNotExists });
+  }
+  async clearTable({ tableName }) {
+    await this.stores.operations.clearTable({ tableName });
+  }
+  async dropTable({ tableName }) {
+    await this.stores.operations.dropTable({ tableName });
+  }
+  insert(args) {
+    return this.stores.operations.insert(args);
+  }
+  batchInsert(args) {
+    return this.stores.operations.batchInsert(args);
+  }
+  async load({ tableName, keys }) {
+    return this.stores.operations.load({ tableName, keys });
+  }
+  async getThreadById({ threadId }) {
+    return this.stores.memory.getThreadById({ threadId });
+  }
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead for paginated results.
+   */
+  async getThreadsByResourceId(args) {
+    return this.stores.memory.getThreadsByResourceId(args);
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    return this.stores.memory.getThreadsByResourceIdPaginated(args);
+  }
+  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 });
+  }
+  async getMessages({
+    threadId,
+    selectBy,
+    format
+  }) {
+    return this.stores.memory.getMessages({ threadId, selectBy, format });
+  }
+  async getMessagesPaginated(args) {
+    return this.stores.memory.getMessagesPaginated(args);
+  }
+  async saveMessages(args) {
+    return this.stores.memory.saveMessages(args);
+  }
+  async updateMessages({
+    messages
+  }) {
+    return this.stores.memory.updateMessages({ messages });
+  }
+  /** @deprecated use getEvals instead */
+  async getEvalsByAgentName(agentName, type) {
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
+  }
+  async getEvals(options = {}) {
+    return this.stores.legacyEvals.getEvals(options);
+  }
+  async getScoreById({ id }) {
+    return this.stores.scores.getScoreById({ id });
+  }
+  async saveScore(score) {
+    return this.stores.scores.saveScore(score);
+  }
+  async getScoresByScorerId({
+    scorerId,
+    entityId,
+    entityType,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByScorerId({ scorerId, entityId, entityType, pagination });
+  }
+  async getScoresByRunId({
+    runId,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByRunId({ runId, pagination });
+  }
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByEntityId({ entityId, entityType, pagination });
+  }
+  /**
+   * TRACES
+   */
+  /**
+   * @deprecated use getTracesPaginated instead.
+   */
+  async getTraces(args) {
+    return this.stores.traces.getTraces(args);
+  }
+  async getTracesPaginated(args) {
+    return this.stores.traces.getTracesPaginated(args);
+  }
+  async batchTraceInsert(args) {
+    return this.stores.traces.batchTraceInsert(args);
+  }
+  /**
+   * WORKFLOWS
+   */
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
+  }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset,
+    resourceId
+  } = {}) {
+    return this.stores.workflows.getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId });
+  }
   async getWorkflowRunById({
     runId,
     workflowName
   }) {
-    const conditions = [];
-    const args = [];
-    if (runId) {
-      conditions.push("run_id = ?");
-      args.push(runId);
-    }
-    if (workflowName) {
-      conditions.push("workflow_name = ?");
-      args.push(workflowName);
-    }
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    try {
-      const result = await this.client.execute({
-        sql: `SELECT * FROM ${TABLE_WORKFLOW_SNAPSHOT} ${whereClause}`,
-        args
-      });
-      if (!result.rows?.[0]) {
-        return null;
-      }
-      return this.parseWorkflowRun(result.rows[0]);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "LIBSQL_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
-        },
-        error
-      );
-    }
+    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
   }
   async getResourceById({ resourceId }) {
-    const result = await this.load({
-      tableName: TABLE_RESOURCES,
-      keys: { id: resourceId }
-    });
-    if (!result) {
-      return null;
-    }
-    return {
-      ...result,
-      // Ensure workingMemory is always returned as a string, even if auto-parsed as JSON
-      workingMemory: typeof result.workingMemory === "object" ? JSON.stringify(result.workingMemory) : result.workingMemory,
-      metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
-    };
+    return this.stores.memory.getResourceById({ resourceId });
   }
   async saveResource({ resource }) {
-    await this.insert({
-      tableName: TABLE_RESOURCES,
-      record: {
-        ...resource,
-        metadata: JSON.stringify(resource.metadata)
-      }
-    });
-    return resource;
+    return this.stores.memory.saveResource({ resource });
   }
   async updateResource({
     resourceId,
     workingMemory,
     metadata
   }) {
-    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 updates = [];
-    const values = [];
-    if (workingMemory !== void 0) {
-      updates.push("workingMemory = ?");
-      values.push(workingMemory);
-    }
-    if (metadata) {
-      updates.push("metadata = ?");
-      values.push(JSON.stringify(updatedResource.metadata));
-    }
-    updates.push("updatedAt = ?");
-    values.push(updatedResource.updatedAt.toISOString());
-    values.push(resourceId);
-    await this.client.execute({
-      sql: `UPDATE ${TABLE_RESOURCES} SET ${updates.join(", ")} WHERE id = ?`,
-      args: values
-    });
-    return updatedResource;
-  }
-  async hasColumn(table, column) {
-    const result = await this.client.execute({
-      sql: `PRAGMA table_info(${table})`
-    });
-    return (await result.rows)?.some((row) => row.name === column);
-  }
-  parseWorkflowRun(row) {
-    let parsedSnapshot = row.snapshot;
-    if (typeof parsedSnapshot === "string") {
-      try {
-        parsedSnapshot = JSON.parse(row.snapshot);
-      } catch (e) {
-        console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
-      }
-    }
-    return {
-      workflowName: row.workflow_name,
-      runId: row.run_id,
-      snapshot: parsedSnapshot,
-      resourceId: row.resourceId,
-      createdAt: new Date(row.createdAt),
-      updatedAt: new Date(row.updatedAt)
-    };
+    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
   }
 };