@mastra/cloudflare-d1 0.0.0-remove-unused-import-20250909212718 → 0.0.0-remove-ai-peer-dep-from-evals-20260105220639

package/dist/index.js

@@ -1,10 +1,28 @@
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
-import { MastraStorage, StoreOperations, ScoresStorage, TABLE_SCORERS, LegacyEvalsStorage, TABLE_EVALS, serializeDate, TracesStorage, TABLE_TRACES, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, ensureDate, MemoryStorage, TABLE_RESOURCES, TABLE_THREADS, TABLE_MESSAGES, resolveMessageLimit, safelyParseJSON } from '@mastra/core/storage';
+import { MemoryStorage, TABLE_SCHEMAS, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, ensureDate, createStorageErrorId, normalizePerPage, calculatePagination, serializeDate, ScoresStorage, TABLE_SCORERS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, MastraStorage, getSqlType, getDefaultValue, transformScoreRow as transformScoreRow$1 } from '@mastra/core/storage';
 import Cloudflare from 'cloudflare';
-import { parseSqlIdentifier } from '@mastra/core/utils';
 import { MessageList } from '@mastra/core/agent';
+import { MastraBase } from '@mastra/core/base';
+import { parseSqlIdentifier } from '@mastra/core/utils';
+import { saveScorePayloadSchema } from '@mastra/core/evals';
 
 // src/storage/index.ts
+
+// src/storage/domains/utils.ts
+function isArrayOfRecords(value) {
+  return value && Array.isArray(value) && value.length > 0;
+}
+function deserializeValue(value, type) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
 var SqlBuilder = class {
   sql = "";
   params = [];
@@ -235,218 +253,483 @@ function parseSelectIdentifier(column) {
   return column;
 }
 
-// src/storage/domains/utils.ts
-function isArrayOfRecords(value) {
-  return value && Array.isArray(value) && value.length > 0;
+// src/storage/db/index.ts
+function resolveD1Config(config) {
+  if ("client" in config) {
+    return {
+      client: config.client,
+      tablePrefix: config.tablePrefix
+    };
+  }
+  if ("binding" in config) {
+    return {
+      binding: config.binding,
+      tablePrefix: config.tablePrefix
+    };
+  }
+  const cfClient = new Cloudflare({ apiToken: config.apiToken });
+  return {
+    client: {
+      query: ({ sql, params }) => {
+        return cfClient.d1.database.query(config.databaseId, {
+          account_id: config.accountId,
+          sql,
+          params
+        });
+      }
+    },
+    tablePrefix: config.tablePrefix
+  };
 }
-function deserializeValue(value, type) {
-  if (value === null || value === void 0) return null;
-  if (type === "date" && typeof value === "string") {
-    return new Date(value);
+var D1DB = class extends MastraBase {
+  client;
+  binding;
+  tablePrefix;
+  constructor(config) {
+    super({
+      component: "STORAGE",
+      name: "D1_DB"
+    });
+    this.client = config.client;
+    this.binding = config.binding;
+    this.tablePrefix = config.tablePrefix || "";
+  }
+  async hasColumn(table, column) {
+    const fullTableName = table.startsWith(this.tablePrefix) ? table : `${this.tablePrefix}${table}`;
+    const sql = `PRAGMA table_info(${fullTableName});`;
+    const result = await this.executeQuery({ sql, params: [] });
+    if (!result || !Array.isArray(result)) return false;
+    return result.some((col) => col.name === column || col.name === column.toLowerCase());
+  }
+  getTableName(tableName) {
+    return `${this.tablePrefix}${tableName}`;
+  }
+  formatSqlParams(params) {
+    return params.map((p) => p === void 0 || p === null ? null : p);
   }
-  if (type === "jsonb" && typeof value === "string") {
+  async executeWorkersBindingQuery({
+    sql,
+    params = [],
+    first = false
+  }) {
+    if (!this.binding) {
+      throw new Error("Workers binding is not configured");
+    }
     try {
-      return JSON.parse(value);
-    } catch {
-      return value;
+      const statement = this.binding.prepare(sql);
+      const formattedParams = this.formatSqlParams(params);
+      let result;
+      if (formattedParams.length > 0) {
+        if (first) {
+          result = await statement.bind(...formattedParams).first();
+          if (!result) return null;
+          return result;
+        } else {
+          result = await statement.bind(...formattedParams).all();
+          const results = result.results || [];
+          return results;
+        }
+      } else {
+        if (first) {
+          result = await statement.first();
+          if (!result) return null;
+          return result;
+        } else {
+          result = await statement.all();
+          const results = result.results || [];
+          return results;
+        }
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_D1", "WORKERS_BINDING_QUERY", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { sql }
+        },
+        error
+      );
     }
   }
-  if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+  async executeRestQuery({
+    sql,
+    params = [],
+    first = false
+  }) {
+    if (!this.client) {
+      throw new Error("D1 client is not configured");
+    }
     try {
-      return JSON.parse(value);
-    } catch {
-      return value;
+      const formattedParams = this.formatSqlParams(params);
+      const response = await this.client.query({
+        sql,
+        params: formattedParams
+      });
+      const result = response.result || [];
+      const results = result.flatMap((r) => r.results || []);
+      if (first) {
+        return results[0] || null;
+      }
+      return results;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_D1", "REST_QUERY", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { sql }
+        },
+        error
+      );
     }
   }
-  return value;
-}
-
-// src/storage/domains/legacy-evals/index.ts
-var LegacyEvalsStorageD1 = class extends LegacyEvalsStorage {
-  operations;
-  constructor({ operations }) {
-    super();
-    this.operations = operations;
-  }
-  async getEvals(options) {
-    const { agentName, type, page = 0, perPage = 40, dateRange } = options || {};
-    const fullTableName = this.operations.getTableName(TABLE_EVALS);
-    const conditions = [];
-    const queryParams = [];
-    if (agentName) {
-      conditions.push(`agent_name = ?`);
-      queryParams.push(agentName);
+  async executeQuery(options) {
+    if (this.binding) {
+      return this.executeWorkersBindingQuery(options);
+    } else if (this.client) {
+      return this.executeRestQuery(options);
+    } else {
+      throw new Error("Neither binding nor client is configured");
+    }
+  }
+  async getTableColumns(tableName) {
+    try {
+      const sql = `PRAGMA table_info(${tableName})`;
+      const result = await this.executeQuery({ sql });
+      if (!result || !Array.isArray(result)) {
+        return [];
+      }
+      return result.map((row) => ({
+        name: row.name,
+        type: row.type
+      }));
+    } catch (error) {
+      this.logger.warn(`Failed to get table columns for ${tableName}:`, error);
+      return [];
     }
-    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)`);
+  }
+  serializeValue(value) {
+    if (value === null || value === void 0) {
+      return null;
     }
-    if (dateRange?.start) {
-      conditions.push(`created_at >= ?`);
-      queryParams.push(serializeDate(dateRange.start));
+    if (value instanceof Date) {
+      return value.toISOString();
     }
-    if (dateRange?.end) {
-      conditions.push(`created_at <= ?`);
-      queryParams.push(serializeDate(dateRange.end));
+    if (typeof value === "object") {
+      return JSON.stringify(value);
     }
-    const countQueryBuilder = createSqlBuilder().count().from(fullTableName);
-    if (conditions.length > 0) {
-      countQueryBuilder.where(conditions.join(" AND "), ...queryParams);
+    return value;
+  }
+  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
+      case "boolean":
+        return "INTEGER";
+      // SQLite uses 0/1 for booleans
+      default:
+        return getSqlType(type);
     }
-    const { sql: countSql, params: countParams } = countQueryBuilder.build();
+  }
+  getDefaultValue(type) {
+    return getDefaultValue(type);
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
     try {
-      const countResult = await this.operations.executeQuery({
-        sql: countSql,
-        params: countParams,
-        first: true
+      const fullTableName = this.getTableName(tableName);
+      const columnDefinitions = Object.entries(schema).map(([colName, colDef]) => {
+        const type = this.getSqlType(colDef.type);
+        const nullable = colDef.nullable === false ? "NOT NULL" : "";
+        const primaryKey = colDef.primaryKey ? "PRIMARY KEY" : "";
+        return `${colName} ${type} ${nullable} ${primaryKey}`.trim();
       });
-      const total = Number(countResult?.count || 0);
-      const currentOffset = page * perPage;
-      if (total === 0) {
-        return {
-          evals: [],
-          total: 0,
-          page,
-          perPage,
-          hasMore: false
-        };
-      }
-      const dataQueryBuilder = createSqlBuilder().select("*").from(fullTableName);
-      if (conditions.length > 0) {
-        dataQueryBuilder.where(conditions.join(" AND "), ...queryParams);
+      const tableConstraints = [];
+      if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
+        tableConstraints.push("UNIQUE (workflow_name, run_id)");
       }
-      dataQueryBuilder.orderBy("created_at", "DESC").limit(perPage).offset(currentOffset);
-      const { sql: dataSql, params: dataParams } = dataQueryBuilder.build();
-      const rows = await this.operations.executeQuery({
-        sql: dataSql,
-        params: dataParams
-      });
-      const evals = (isArrayOfRecords(rows) ? rows : []).map((row) => {
-        const result = deserializeValue(row.result);
-        const testInfo = row.test_info ? deserializeValue(row.test_info) : void 0;
-        if (!result || typeof result !== "object" || !("score" in result)) {
-          throw new Error(`Invalid MetricResult format: ${JSON.stringify(result)}`);
-        }
-        return {
-          input: row.input,
-          output: row.output,
-          result,
-          agentName: row.agent_name,
-          metricName: row.metric_name,
-          instructions: row.instructions,
-          testInfo,
-          globalRunId: row.global_run_id,
-          runId: row.run_id,
-          createdAt: row.created_at
-        };
-      });
-      const hasMore = currentOffset + evals.length < total;
-      return {
-        evals,
-        total,
-        page,
-        perPage,
-        hasMore
-      };
+      const query = createSqlBuilder().createTable(fullTableName, columnDefinitions, tableConstraints);
+      const { sql, params } = query.build();
+      await this.executeQuery({ sql, params });
+      this.logger.debug(`Created table ${fullTableName}`);
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_EVALS_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "CREATE_TABLE", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          text: `Failed to retrieve evals for agent ${agentName}: ${error instanceof Error ? error.message : String(error)}`,
-          details: { agentName: agentName ?? "", type: type ?? "" }
+          details: { tableName }
         },
         error
       );
     }
   }
-  /**
-   * @deprecated use getEvals instead
-   */
-  async getEvalsByAgentName(agentName, type) {
-    const fullTableName = this.operations.getTableName(TABLE_EVALS);
+  async clearTable({ tableName }) {
     try {
-      let query = createSqlBuilder().select("*").from(fullTableName).where("agent_name = ?", agentName);
-      if (type === "test") {
-        query = query.andWhere("test_info IS NOT NULL AND json_extract(test_info, '$.testPath') IS NOT NULL");
-      } else if (type === "live") {
-        query = query.andWhere("(test_info IS NULL OR json_extract(test_info, '$.testPath') IS NULL)");
-      }
-      query.orderBy("created_at", "DESC");
+      const fullTableName = this.getTableName(tableName);
+      const query = createSqlBuilder().delete(fullTableName);
       const { sql, params } = query.build();
-      const results = await this.operations.executeQuery({ sql, params });
-      return isArrayOfRecords(results) ? results.map((row) => {
-        const result = deserializeValue(row.result);
-        const testInfo = row.test_info ? deserializeValue(row.test_info) : void 0;
-        return {
-          input: row.input || "",
-          output: row.output || "",
-          result,
-          agentName: row.agent_name || "",
-          metricName: row.metric_name || "",
-          instructions: row.instructions || "",
-          runId: row.run_id || "",
-          globalRunId: row.global_run_id || "",
-          createdAt: row.created_at || "",
-          testInfo
-        };
-      }) : [];
+      await this.executeQuery({ sql, params });
+      this.logger.debug(`Cleared table ${fullTableName}`);
     } catch (error) {
-      const mastraError = new MastraError(
+      throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_EVALS_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "CLEAR_TABLE", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          text: `Failed to retrieve evals for agent ${agentName}: ${error instanceof Error ? error.message : String(error)}`,
-          details: { agentName }
+          details: { tableName }
         },
         error
       );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return [];
     }
   }
-};
-var MemoryStorageD1 = class extends MemoryStorage {
-  operations;
-  constructor({ operations }) {
-    super();
-    this.operations = operations;
-  }
-  async getResourceById({ resourceId }) {
-    const resource = await this.operations.load({
-      tableName: TABLE_RESOURCES,
-      keys: { id: resourceId }
-    });
-    if (!resource) return null;
+  async dropTable({ tableName }) {
     try {
-      return {
-        ...resource,
-        createdAt: ensureDate(resource.createdAt),
-        updatedAt: ensureDate(resource.updatedAt),
-        metadata: typeof resource.metadata === "string" ? JSON.parse(resource.metadata || "{}") : resource.metadata
-      };
+      const fullTableName = this.getTableName(tableName);
+      const sql = `DROP TABLE IF EXISTS ${fullTableName}`;
+      await this.executeQuery({ sql });
+      this.logger.debug(`Dropped table ${fullTableName}`);
     } catch (error) {
-      const mastraError = new MastraError(
+      throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_RESOURCE_BY_ID_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "DROP_TABLE", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          text: `Error processing resource ${resourceId}: ${error instanceof Error ? error.message : String(error)}`,
-          details: { resourceId }
+          details: { tableName }
         },
         error
       );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return null;
+    }
+  }
+  async alterTable(args) {
+    try {
+      const fullTableName = this.getTableName(args.tableName);
+      const existingColumns = await this.getTableColumns(fullTableName);
+      const existingColumnNames = new Set(existingColumns.map((col) => col.name));
+      for (const [columnName, column] of Object.entries(args.schema)) {
+        if (!existingColumnNames.has(columnName) && args.ifNotExists.includes(columnName)) {
+          const sqlType = this.getSqlType(column.type);
+          const defaultValue = this.getDefaultValue(column.type);
+          const sql = `ALTER TABLE ${fullTableName} ADD COLUMN ${columnName} ${sqlType} ${defaultValue}`;
+          await this.executeQuery({ sql });
+          this.logger.debug(`Added column ${columnName} to table ${fullTableName}`);
+        }
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_D1", "ALTER_TABLE", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName: args.tableName }
+        },
+        error
+      );
+    }
+  }
+  async insert({ tableName, record }) {
+    try {
+      const fullTableName = this.getTableName(tableName);
+      const processedRecord = await this.processRecord(record);
+      const columns = Object.keys(processedRecord);
+      const values = Object.values(processedRecord);
+      const query = createSqlBuilder().insert(fullTableName, columns, values);
+      const { sql, params } = query.build();
+      await this.executeQuery({ sql, params });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_D1", "INSERT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  async batchInsert({ tableName, records }) {
+    try {
+      if (records.length === 0) return;
+      const fullTableName = this.getTableName(tableName);
+      const processedRecords = await Promise.all(records.map((record) => this.processRecord(record)));
+      const columns = Object.keys(processedRecords[0] || {});
+      for (const record of processedRecords) {
+        const values = Object.values(record);
+        const query = createSqlBuilder().insert(fullTableName, columns, values);
+        const { sql, params } = query.build();
+        await this.executeQuery({ sql, params });
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_D1", "BATCH_INSERT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  async load({ tableName, keys }) {
+    try {
+      const fullTableName = this.getTableName(tableName);
+      const query = createSqlBuilder().select("*").from(fullTableName);
+      let firstKey = true;
+      for (const [key, value] of Object.entries(keys)) {
+        if (firstKey) {
+          query.where(`${key} = ?`, value);
+          firstKey = false;
+        } else {
+          query.andWhere(`${key} = ?`, value);
+        }
+      }
+      query.orderBy("createdAt", "DESC");
+      query.limit(1);
+      const { sql, params } = query.build();
+      const result = await this.executeQuery({ sql, params, first: true });
+      if (!result) {
+        return null;
+      }
+      const deserializedResult = {};
+      for (const [key, value] of Object.entries(result)) {
+        deserializedResult[key] = deserializeValue(value);
+      }
+      return deserializedResult;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_D1", "LOAD", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  async processRecord(record) {
+    const processed = {};
+    for (const [key, value] of Object.entries(record)) {
+      processed[key] = this.serializeValue(value);
+    }
+    return processed;
+  }
+  /**
+   * Upsert multiple records in a batch operation
+   * @param tableName The table to insert into
+   * @param records The records to insert
+   */
+  async batchUpsert({ tableName, records }) {
+    if (records.length === 0) return;
+    const fullTableName = this.getTableName(tableName);
+    try {
+      const batchSize = 50;
+      for (let i = 0; i < records.length; i += batchSize) {
+        const batch = records.slice(i, i + batchSize);
+        const recordsToInsert = batch;
+        if (recordsToInsert.length > 0) {
+          const firstRecord = recordsToInsert[0];
+          const columns = Object.keys(firstRecord || {});
+          for (const record of recordsToInsert) {
+            const values = columns.map((col) => {
+              if (!record) return null;
+              const value = typeof col === "string" ? record[col] : null;
+              return this.serializeValue(value);
+            });
+            const recordToUpsert = columns.reduce(
+              (acc, col) => {
+                if (col !== "createdAt") acc[col] = `excluded.${col}`;
+                return acc;
+              },
+              {}
+            );
+            const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], recordToUpsert);
+            const { sql, params } = query.build();
+            await this.executeQuery({ sql, params });
+          }
+        }
+        this.logger.debug(
+          `Processed batch ${Math.floor(i / batchSize) + 1} of ${Math.ceil(records.length / batchSize)}`
+        );
+      }
+      this.logger.debug(`Successfully batch upserted ${records.length} records into ${tableName}`);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_D1", "BATCH_UPSERT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to batch upsert into ${tableName}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+};
+
+// src/storage/domains/memory/index.ts
+var MemoryStorageD1 = class extends MemoryStorage {
+  #db;
+  constructor(config) {
+    super();
+    this.#db = new D1DB(resolveD1Config(config));
+  }
+  async init() {
+    await this.#db.createTable({ tableName: TABLE_THREADS, schema: TABLE_SCHEMAS[TABLE_THREADS] });
+    await this.#db.createTable({ tableName: TABLE_MESSAGES, schema: TABLE_SCHEMAS[TABLE_MESSAGES] });
+    await this.#db.createTable({ tableName: TABLE_RESOURCES, schema: TABLE_SCHEMAS[TABLE_RESOURCES] });
+    await this.#db.alterTable({
+      tableName: TABLE_MESSAGES,
+      schema: TABLE_SCHEMAS[TABLE_MESSAGES],
+      ifNotExists: ["resourceId"]
+    });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: TABLE_MESSAGES });
+    await this.#db.clearTable({ tableName: TABLE_THREADS });
+    await this.#db.clearTable({ tableName: TABLE_RESOURCES });
+  }
+  async getResourceById({ resourceId }) {
+    const resource = await this.#db.load({
+      tableName: TABLE_RESOURCES,
+      keys: { id: resourceId }
+    });
+    if (!resource) return null;
+    try {
+      return {
+        ...resource,
+        createdAt: ensureDate(resource.createdAt),
+        updatedAt: ensureDate(resource.updatedAt),
+        metadata: typeof resource.metadata === "string" ? JSON.parse(resource.metadata || "{}") : resource.metadata
+      };
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_D1", "GET_RESOURCE_BY_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Error processing resource ${resourceId}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { resourceId }
+        },
+        error
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return null;
     }
   }
   async saveResource({ resource }) {
-    const fullTableName = this.operations.getTableName(TABLE_RESOURCES);
+    const fullTableName = this.#db.getTableName(TABLE_RESOURCES);
     const resourceToSave = {
       id: resource.id,
       workingMemory: resource.workingMemory,
@@ -454,7 +737,7 @@ var MemoryStorageD1 = class extends MemoryStorage {
       createdAt: resource.createdAt,
       updatedAt: resource.updatedAt
     };
-    const processedRecord = await this.operations.processRecord(resourceToSave);
+    const processedRecord = await this.#db.processRecord(resourceToSave);
     const columns = Object.keys(processedRecord);
     const values = Object.values(processedRecord);
     const updateMap = {
@@ -466,12 +749,12 @@ var MemoryStorageD1 = class extends MemoryStorage {
     const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], updateMap);
     const { sql, params } = query.build();
     try {
-      await this.operations.executeQuery({ sql, params });
+      await this.#db.executeQuery({ sql, params });
       return resource;
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_SAVE_RESOURCE_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "SAVE_RESOURCE", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           text: `Failed to save resource to ${fullTableName}: ${error instanceof Error ? error.message : String(error)}`,
@@ -507,18 +790,18 @@ var MemoryStorageD1 = class extends MemoryStorage {
       },
       updatedAt
     };
-    const fullTableName = this.operations.getTableName(TABLE_RESOURCES);
+    const fullTableName = this.#db.getTableName(TABLE_RESOURCES);
     const columns = ["workingMemory", "metadata", "updatedAt"];
     const values = [updatedResource.workingMemory, JSON.stringify(updatedResource.metadata), updatedAt.toISOString()];
     const query = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", resourceId);
     const { sql, params } = query.build();
     try {
-      await this.operations.executeQuery({ sql, params });
+      await this.#db.executeQuery({ sql, params });
       return updatedResource;
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_UPDATE_RESOURCE_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "UPDATE_RESOURCE", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           text: `Failed to update resource ${resourceId}: ${error instanceof Error ? error.message : String(error)}`,
@@ -529,7 +812,7 @@ var MemoryStorageD1 = class extends MemoryStorage {
     }
   }
   async getThreadById({ threadId }) {
-    const thread = await this.operations.load({
+    const thread = await this.#db.load({
       tableName: TABLE_THREADS,
       keys: { id: threadId }
     });
@@ -544,7 +827,7 @@ var MemoryStorageD1 = class extends MemoryStorage {
     } catch (error) {
       const mastraError = new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_THREAD_BY_ID_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "GET_THREAD_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           text: `Error processing thread ${threadId}: ${error instanceof Error ? error.message : String(error)}`,
@@ -557,40 +840,23 @@ var MemoryStorageD1 = class extends MemoryStorage {
       return null;
     }
   }
-  /**
-   * @deprecated use getThreadsByResourceIdPaginated instead
-   */
-  async getThreadsByResourceId({ resourceId }) {
-    const fullTableName = this.operations.getTableName(TABLE_THREADS);
-    try {
-      const query = createSqlBuilder().select("*").from(fullTableName).where("resourceId = ?", resourceId);
-      const { sql, params } = query.build();
-      const results = await this.operations.executeQuery({ sql, params });
-      return (isArrayOfRecords(results) ? results : []).map((thread) => ({
-        ...thread,
-        createdAt: ensureDate(thread.createdAt),
-        updatedAt: ensureDate(thread.updatedAt),
-        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata || "{}") : thread.metadata || {}
-      }));
-    } catch (error) {
-      const mastraError = new MastraError(
+  async listThreadsByResourceId(args) {
+    const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
+    const perPage = normalizePerPage(perPageInput, 100);
+    if (page < 0) {
+      throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_THREADS_BY_RESOURCE_ID_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "LIST_THREADS_BY_RESOURCE_ID", "INVALID_PAGE"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          text: `Error getting threads by resourceId ${resourceId}: ${error instanceof Error ? error.message : String(error)}`,
-          details: { resourceId }
+          category: ErrorCategory.USER,
+          details: { page }
         },
-        error
+        new Error("page must be >= 0")
       );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return [];
     }
-  }
-  async getThreadsByResourceIdPaginated(args) {
-    const { resourceId, page, perPage } = args;
-    const fullTableName = this.operations.getTableName(TABLE_THREADS);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    const { field, direction } = this.parseOrderBy(orderBy);
+    const fullTableName = this.#db.getTableName(TABLE_THREADS);
     const mapRowToStorageThreadType = (row) => ({
       ...row,
       createdAt: ensureDate(row.createdAt),
@@ -599,22 +865,23 @@ var MemoryStorageD1 = class extends MemoryStorage {
     });
     try {
       const countQuery = createSqlBuilder().count().from(fullTableName).where("resourceId = ?", resourceId);
-      const countResult = await this.operations.executeQuery(countQuery.build());
+      const countResult = await this.#db.executeQuery(countQuery.build());
       const total = Number(countResult?.[0]?.count ?? 0);
-      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("resourceId = ?", resourceId).orderBy("createdAt", "DESC").limit(perPage).offset(page * perPage);
-      const results = await this.operations.executeQuery(selectQuery.build());
+      const limitValue = perPageInput === false ? total : perPage;
+      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("resourceId = ?", resourceId).orderBy(field, direction).limit(limitValue).offset(offset);
+      const results = await this.#db.executeQuery(selectQuery.build());
       const threads = results.map(mapRowToStorageThreadType);
       return {
         threads,
         total,
         page,
-        perPage,
-        hasMore: page * perPage + threads.length < total
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
       };
     } catch (error) {
       const mastraError = new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "LIST_THREADS_BY_RESOURCE_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           text: `Error getting threads by resourceId ${resourceId}: ${error instanceof Error ? error.message : String(error)}`,
@@ -628,13 +895,13 @@ var MemoryStorageD1 = class extends MemoryStorage {
         threads: [],
         total: 0,
         page,
-        perPage,
+        perPage: perPageForResponse,
         hasMore: false
       };
     }
   }
   async saveThread({ thread }) {
-    const fullTableName = this.operations.getTableName(TABLE_THREADS);
+    const fullTableName = this.#db.getTableName(TABLE_THREADS);
     const threadToSave = {
       id: thread.id,
       resourceId: thread.resourceId,
@@ -643,7 +910,7 @@ var MemoryStorageD1 = class extends MemoryStorage {
       createdAt: thread.createdAt.toISOString(),
       updatedAt: thread.updatedAt.toISOString()
     };
-    const processedRecord = await this.operations.processRecord(threadToSave);
+    const processedRecord = await this.#db.processRecord(threadToSave);
     const columns = Object.keys(processedRecord);
     const values = Object.values(processedRecord);
     const updateMap = {
@@ -656,12 +923,12 @@ var MemoryStorageD1 = class extends MemoryStorage {
     const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], updateMap);
     const { sql, params } = query.build();
     try {
-      await this.operations.executeQuery({ sql, params });
+      await this.#db.executeQuery({ sql, params });
       return thread;
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_SAVE_THREAD_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "SAVE_THREAD", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           text: `Failed to save thread to ${fullTableName}: ${error instanceof Error ? error.message : String(error)}`,
@@ -681,7 +948,7 @@ var MemoryStorageD1 = class extends MemoryStorage {
       if (!thread) {
         throw new Error(`Thread ${id} not found`);
       }
-      const fullTableName = this.operations.getTableName(TABLE_THREADS);
+      const fullTableName = this.#db.getTableName(TABLE_THREADS);
       const mergedMetadata = {
         ...typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
         ...metadata
@@ -691,7 +958,7 @@ var MemoryStorageD1 = class extends MemoryStorage {
       const values = [title, JSON.stringify(mergedMetadata), updatedAt.toISOString()];
       const query = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", id);
       const { sql, params } = query.build();
-      await this.operations.executeQuery({ sql, params });
+      await this.#db.executeQuery({ sql, params });
       return {
         ...thread,
         title,
@@ -704,7 +971,7 @@ var MemoryStorageD1 = class extends MemoryStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_UPDATE_THREAD_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "UPDATE_THREAD", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           text: `Failed to update thread ${id}: ${error instanceof Error ? error.message : String(error)}`,
@@ -715,19 +982,19 @@ var MemoryStorageD1 = class extends MemoryStorage {
     }
   }
   async deleteThread({ threadId }) {
-    const fullTableName = this.operations.getTableName(TABLE_THREADS);
+    const fullTableName = this.#db.getTableName(TABLE_THREADS);
     try {
       const deleteThreadQuery = createSqlBuilder().delete(fullTableName).where("id = ?", threadId);
       const { sql: threadSql, params: threadParams } = deleteThreadQuery.build();
-      await this.operations.executeQuery({ sql: threadSql, params: threadParams });
-      const messagesTableName = this.operations.getTableName(TABLE_MESSAGES);
+      await this.#db.executeQuery({ sql: threadSql, params: threadParams });
+      const messagesTableName = this.#db.getTableName(TABLE_MESSAGES);
       const deleteMessagesQuery = createSqlBuilder().delete(messagesTableName).where("thread_id = ?", threadId);
       const { sql: messagesSql, params: messagesParams } = deleteMessagesQuery.build();
-      await this.operations.executeQuery({ sql: messagesSql, params: messagesParams });
+      await this.#db.executeQuery({ sql: messagesSql, params: messagesParams });
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_DELETE_THREAD_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "DELETE_THREAD", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           text: `Failed to delete thread ${threadId}: ${error instanceof Error ? error.message : String(error)}`,
@@ -738,8 +1005,8 @@ var MemoryStorageD1 = class extends MemoryStorage {
     }
   }
   async saveMessages(args) {
-    const { messages, format = "v1" } = args;
-    if (messages.length === 0) return [];
+    const { messages } = args;
+    if (messages.length === 0) return { messages: [] };
     try {
       const now = /* @__PURE__ */ new Date();
       const threadId = messages[0]?.threadId;
@@ -775,24 +1042,23 @@ var MemoryStorageD1 = class extends MemoryStorage {
         };
       });
       await Promise.all([
-        this.operations.batchUpsert({
+        this.#db.batchUpsert({
           tableName: TABLE_MESSAGES,
           records: messagesToInsert
         }),
         // Update thread's updatedAt timestamp
-        this.operations.executeQuery({
-          sql: `UPDATE ${this.operations.getTableName(TABLE_THREADS)} SET updatedAt = ? WHERE id = ?`,
+        this.#db.executeQuery({
+          sql: `UPDATE ${this.#db.getTableName(TABLE_THREADS)} SET updatedAt = ? WHERE id = ?`,
           params: [now.toISOString(), threadId]
         })
       ]);
       this.logger.debug(`Saved ${messages.length} messages`);
       const list = new MessageList().add(messages, "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
+      return { messages: list.get.all.db() };
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_SAVE_MESSAGES_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "SAVE_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           text: `Failed to save messages: ${error instanceof Error ? error.message : String(error)}`
@@ -801,24 +1067,25 @@ var MemoryStorageD1 = class extends MemoryStorage {
       );
     }
   }
-  async _getIncludedMessages(threadId, selectBy) {
-    if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-    const include = selectBy?.include;
-    if (!include) return null;
+  async _getIncludedMessages(include) {
+    if (!include || include.length === 0) return null;
     const unionQueries = [];
     const params = [];
     let paramIdx = 1;
+    const tableName = this.#db.getTableName(TABLE_MESSAGES);
     for (const inc of include) {
       const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
-      const searchId = inc.threadId || threadId;
       unionQueries.push(`
                 SELECT * FROM (
-                  WITH ordered_messages AS (
+                  WITH target_thread AS (
+                    SELECT thread_id FROM ${tableName} WHERE id = ?
+                  ),
+                  ordered_messages AS (
                     SELECT
                       *,
                       ROW_NUMBER() OVER (ORDER BY createdAt ASC) AS row_num
-                    FROM ${this.operations.getTableName(TABLE_MESSAGES)}
-                    WHERE thread_id = ?
+                    FROM ${tableName}
+                    WHERE thread_id = (SELECT thread_id FROM target_thread)
                   )
                   SELECT
                     m.id,
@@ -841,11 +1108,11 @@ var MemoryStorageD1 = class extends MemoryStorage {
                   )
                 ) AS query_${paramIdx}
             `);
-      params.push(searchId, id, id, withNextMessages, withPreviousMessages);
+      params.push(id, id, id, withNextMessages, withPreviousMessages);
       paramIdx++;
     }
     const finalQuery = unionQueries.join(" UNION ALL ") + " ORDER BY createdAt ASC";
-    const messages = await this.operations.executeQuery({ sql: finalQuery, params });
+    const messages = await this.#db.executeQuery({ sql: finalQuery, params });
     if (!Array.isArray(messages)) {
       return [];
     }
@@ -859,41 +1126,16 @@ var MemoryStorageD1 = class extends MemoryStorage {
     });
     return processedMessages;
   }
-  async getMessages({
-    threadId,
-    resourceId,
-    selectBy,
-    format
-  }) {
+  async listMessagesById({ messageIds }) {
+    if (messageIds.length === 0) return { messages: [] };
+    const fullTableName = this.#db.getTableName(TABLE_MESSAGES);
+    const messages = [];
     try {
-      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-      const fullTableName = this.operations.getTableName(TABLE_MESSAGES);
-      const limit = resolveMessageLimit({
-        last: selectBy?.last,
-        defaultLimit: 40
-      });
-      const include = selectBy?.include || [];
-      const messages = [];
-      if (include.length) {
-        const includeResult = await this._getIncludedMessages(threadId, selectBy);
-        if (Array.isArray(includeResult)) messages.push(...includeResult);
-      }
-      const excludeIds = messages.map((m) => m.id);
-      const query = createSqlBuilder().select(["id", "content", "role", "type", "createdAt", "thread_id AS threadId"]).from(fullTableName).where("thread_id = ?", threadId);
-      if (excludeIds.length > 0) {
-        query.andWhere(`id NOT IN (${excludeIds.map(() => "?").join(",")})`, ...excludeIds);
-      }
-      query.orderBy("createdAt", "DESC").limit(limit);
+      const query = createSqlBuilder().select(["id", "content", "role", "type", "createdAt", "thread_id AS threadId", "resourceId"]).from(fullTableName).where(`id in (${messageIds.map(() => "?").join(",")})`, ...messageIds);
+      query.orderBy("createdAt", "DESC");
       const { sql, params } = query.build();
-      const result = await this.operations.executeQuery({ sql, params });
+      const result = await this.#db.executeQuery({ sql, params });
       if (Array.isArray(result)) messages.push(...result);
-      messages.sort((a, b) => {
-        const aRecord = a;
-        const bRecord = b;
-        const timeA = new Date(aRecord.createdAt).getTime();
-        const timeB = new Date(bRecord.createdAt).getTime();
-        return timeA - timeB;
-      });
       const processedMessages = messages.map((message) => {
         const processedMsg = {};
         for (const [key, value] of Object.entries(message)) {
@@ -902,18 +1144,17 @@ var MemoryStorageD1 = class extends MemoryStorage {
         }
         return processedMsg;
       });
-      this.logger.debug(`Retrieved ${messages.length} messages for thread ${threadId}`);
+      this.logger.debug(`Retrieved ${messages.length} messages`);
       const list = new MessageList().add(processedMessages, "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
+      return { messages: list.get.all.db() };
     } catch (error) {
       const mastraError = new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_MESSAGES_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "LIST_MESSAGES_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          text: `Failed to retrieve messages for thread ${threadId}: ${error instanceof Error ? error.message : String(error)}`,
-          details: { threadId, resourceId: resourceId ?? "" }
+          text: `Failed to retrieve messages by ID: ${error instanceof Error ? error.message : String(error)}`,
+          details: { messageIds: JSON.stringify(messageIds) }
         },
         error
       );
@@ -922,20 +1163,66 @@ var MemoryStorageD1 = class extends MemoryStorage {
       throw mastraError;
     }
   }
-  async getMessagesById({
-    messageIds,
-    format
-  }) {
-    if (messageIds.length === 0) return [];
-    const fullTableName = this.operations.getTableName(TABLE_MESSAGES);
-    const messages = [];
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    const threadIds = Array.isArray(threadId) ? threadId : [threadId];
+    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_D1", "LIST_MESSAGES", "INVALID_THREAD_ID"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: Array.isArray(threadId) ? threadId.join(",") : threadId }
+        },
+        new Error("threadId must be a non-empty string or array of non-empty strings")
+      );
+    }
+    if (page < 0) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_D1", "LIST_MESSAGES", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
     try {
-      const query = createSqlBuilder().select(["id", "content", "role", "type", "createdAt", "thread_id AS threadId", "resourceId"]).from(fullTableName).where(`id in (${messageIds.map(() => "?").join(",")})`, ...messageIds);
-      query.orderBy("createdAt", "DESC");
-      const { sql, params } = query.build();
-      const result = await this.operations.executeQuery({ sql, params });
-      if (Array.isArray(result)) messages.push(...result);
-      const processedMessages = messages.map((message) => {
+      const fullTableName = this.#db.getTableName(TABLE_MESSAGES);
+      let query = `
+        SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId
+        FROM ${fullTableName}
+        WHERE thread_id = ?
+      `;
+      const queryParams = [threadId];
+      if (resourceId) {
+        query += ` AND resourceId = ?`;
+        queryParams.push(resourceId);
+      }
+      const dateRange = filter?.dateRange;
+      if (dateRange?.start) {
+        const startDate = dateRange.start instanceof Date ? serializeDate(dateRange.start) : serializeDate(new Date(dateRange.start));
+        const startOp = dateRange.startExclusive ? ">" : ">=";
+        query += ` AND createdAt ${startOp} ?`;
+        queryParams.push(startDate);
+      }
+      if (dateRange?.end) {
+        const endDate = dateRange.end instanceof Date ? serializeDate(dateRange.end) : serializeDate(new Date(dateRange.end));
+        const endOp = dateRange.endExclusive ? "<" : "<=";
+        query += ` AND createdAt ${endOp} ?`;
+        queryParams.push(endDate);
+      }
+      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+      query += ` ORDER BY "${field}" ${direction}`;
+      if (perPage !== Number.MAX_SAFE_INTEGER) {
+        query += ` LIMIT ? OFFSET ?`;
+        queryParams.push(perPage, offset);
+      }
+      const results = await this.#db.executeQuery({ sql: query, params: queryParams });
+      const paginatedMessages = (isArrayOfRecords(results) ? results : []).map((message) => {
         const processedMsg = {};
         for (const [key, value] of Object.entries(message)) {
           if (key === `type` && value === `v2`) continue;
@@ -943,138 +1230,95 @@ var MemoryStorageD1 = class extends MemoryStorage {
         }
         return processedMsg;
       });
-      this.logger.debug(`Retrieved ${messages.length} messages`);
-      const list = new MessageList().add(processedMessages, "memory");
-      if (format === `v1`) return list.get.all.v1();
-      return list.get.all.v2();
-    } catch (error) {
-      const mastraError = new MastraError(
-        {
-          id: "CLOUDFLARE_D1_STORAGE_GET_MESSAGES_BY_ID_ERROR",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          text: `Failed to retrieve messages by ID: ${error instanceof Error ? error.message : String(error)}`,
-          details: { messageIds: JSON.stringify(messageIds) }
-        },
-        error
-      );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      throw mastraError;
-    }
-  }
-  async getMessagesPaginated({
-    threadId,
-    resourceId,
-    selectBy,
-    format
-  }) {
-    const { dateRange, page = 0, perPage: perPageInput } = selectBy?.pagination || {};
-    const { start: fromDate, end: toDate } = dateRange || {};
-    const perPage = perPageInput !== void 0 ? perPageInput : resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
-    const fullTableName = this.operations.getTableName(TABLE_MESSAGES);
-    const messages = [];
-    try {
-      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-      if (selectBy?.include?.length) {
-        const includeResult = await this._getIncludedMessages(threadId, selectBy);
-        if (Array.isArray(includeResult)) messages.push(...includeResult);
+      const paginatedCount = paginatedMessages.length;
+      let countQuery = `SELECT count() as count FROM ${fullTableName} WHERE thread_id = ?`;
+      const countParams = [threadId];
+      if (resourceId) {
+        countQuery += ` AND resourceId = ?`;
+        countParams.push(resourceId);
       }
-      const countQuery = createSqlBuilder().count().from(fullTableName).where("thread_id = ?", threadId);
-      if (fromDate) {
-        countQuery.andWhere("createdAt >= ?", serializeDate(fromDate));
+      if (dateRange?.start) {
+        const startDate = dateRange.start instanceof Date ? serializeDate(dateRange.start) : serializeDate(new Date(dateRange.start));
+        const startOp = dateRange.startExclusive ? ">" : ">=";
+        countQuery += ` AND createdAt ${startOp} ?`;
+        countParams.push(startDate);
       }
-      if (toDate) {
-        countQuery.andWhere("createdAt <= ?", serializeDate(toDate));
+      if (dateRange?.end) {
+        const endDate = dateRange.end instanceof Date ? serializeDate(dateRange.end) : serializeDate(new Date(dateRange.end));
+        const endOp = dateRange.endExclusive ? "<" : "<=";
+        countQuery += ` AND createdAt ${endOp} ?`;
+        countParams.push(endDate);
       }
-      const countResult = await this.operations.executeQuery(countQuery.build());
+      const countResult = await this.#db.executeQuery({ sql: countQuery, params: countParams });
       const total = Number(countResult[0]?.count ?? 0);
-      if (total === 0 && messages.length === 0) {
+      if (total === 0 && paginatedCount === 0 && (!include || include.length === 0)) {
         return {
           messages: [],
           total: 0,
           page,
-          perPage,
+          perPage: perPageForResponse,
           hasMore: false
         };
       }
-      const excludeIds = messages.map((m) => m.id);
-      const excludeCondition = excludeIds.length > 0 ? `AND id NOT IN (${excludeIds.map(() => "?").join(",")})` : "";
-      let query;
-      let queryParams = [threadId];
-      if (fromDate) {
-        queryParams.push(serializeDate(fromDate));
-      }
-      if (toDate) {
-        queryParams.push(serializeDate(toDate));
-      }
-      if (excludeIds.length > 0) {
-        queryParams.push(...excludeIds);
-      }
-      if (selectBy?.last && selectBy.last > 0) {
-        query = `
-                    SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId
-                    FROM ${fullTableName}
-                    WHERE thread_id = ?
-                    ${fromDate ? "AND createdAt >= ?" : ""}
-                    ${toDate ? "AND createdAt <= ?" : ""}
-                    ${excludeCondition}
-                    ORDER BY createdAt DESC
-                    LIMIT ?
-                `;
-        queryParams.push(selectBy.last);
-      } else {
-        query = `
-                    SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId
-                    FROM ${fullTableName}
-                    WHERE thread_id = ?
-                    ${fromDate ? "AND createdAt >= ?" : ""}
-                    ${toDate ? "AND createdAt <= ?" : ""}
-                    ${excludeCondition}
-                    ORDER BY createdAt DESC
-                    LIMIT ? OFFSET ?
-                `;
-        queryParams.push(perPage, page * perPage);
+      const messageIds = new Set(paginatedMessages.map((m) => m.id));
+      let includeMessages = [];
+      if (include && include.length > 0) {
+        const includeResult = await this._getIncludedMessages(include);
+        if (Array.isArray(includeResult)) {
+          includeMessages = includeResult;
+          for (const includeMsg of includeMessages) {
+            if (!messageIds.has(includeMsg.id)) {
+              paginatedMessages.push(includeMsg);
+              messageIds.add(includeMsg.id);
+            }
+          }
+        }
       }
-      const results = await this.operations.executeQuery({ sql: query, params: queryParams });
-      const processedMessages = results.map((message) => {
-        const processedMsg = {};
-        for (const [key, value] of Object.entries(message)) {
-          if (key === `type` && value === `v2`) continue;
-          processedMsg[key] = deserializeValue(value);
+      const list = new MessageList().add(paginatedMessages, "memory");
+      let finalMessages = list.get.all.db();
+      finalMessages = finalMessages.sort((a, b) => {
+        const isDateField = field === "createdAt" || field === "updatedAt";
+        const aValue = isDateField ? new Date(a[field]).getTime() : a[field];
+        const bValue = isDateField ? new Date(b[field]).getTime() : b[field];
+        if (aValue === bValue) {
+          return a.id.localeCompare(b.id);
         }
-        return processedMsg;
+        if (typeof aValue === "number" && typeof bValue === "number") {
+          return direction === "ASC" ? aValue - bValue : bValue - aValue;
+        }
+        return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
       });
-      if (selectBy?.last) {
-        processedMessages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-      }
-      const list = new MessageList().add(processedMessages, "memory");
-      messages.push(...format === `v2` ? list.get.all.v2() : list.get.all.v1());
+      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
+      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
+      const hasMore = perPageInput === false ? false : allThreadMessagesReturned ? false : offset + paginatedCount < total;
       return {
-        messages,
+        messages: finalMessages,
         total,
         page,
-        perPage,
-        hasMore: selectBy?.last ? false : page * perPage + messages.length < total
+        perPage: perPageForResponse,
+        hasMore
       };
     } catch (error) {
       const mastraError = new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_MESSAGES_PAGINATED_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "LIST_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          text: `Failed to retrieve messages for thread ${threadId}: ${error instanceof Error ? error.message : String(error)}`,
-          details: { threadId, resourceId: resourceId ?? "" }
+          text: `Failed to list messages for thread ${Array.isArray(threadId) ? threadId.join(",") : threadId}: ${error instanceof Error ? error.message : String(error)}`,
+          details: {
+            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
+            resourceId: resourceId ?? ""
+          }
         },
         error
       );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
       return {
         messages: [],
         total: 0,
         page,
-        perPage,
+        perPage: perPageForResponse,
         hasMore: false
       };
     }
@@ -1086,12 +1330,12 @@ var MemoryStorageD1 = class extends MemoryStorage {
       return [];
     }
     const messageIds = messages.map((m) => m.id);
-    const fullTableName = this.operations.getTableName(TABLE_MESSAGES);
-    const threadsTableName = this.operations.getTableName(TABLE_THREADS);
+    const fullTableName = this.#db.getTableName(TABLE_MESSAGES);
+    const threadsTableName = this.#db.getTableName(TABLE_THREADS);
     try {
       const placeholders = messageIds.map(() => "?").join(",");
       const selectQuery = `SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId FROM ${fullTableName} WHERE id IN (${placeholders})`;
-      const existingMessages = await this.operations.executeQuery({ sql: selectQuery, params: messageIds });
+      const existingMessages = await this.#db.executeQuery({ sql: selectQuery, params: messageIds });
       if (existingMessages.length === 0) {
         return [];
       }
@@ -1149,15 +1393,15 @@ var MemoryStorageD1 = class extends MemoryStorage {
         }
       }
       for (const query of updateQueries) {
-        await this.operations.executeQuery(query);
+        await this.#db.executeQuery(query);
       }
       if (threadIdsToUpdate.size > 0) {
         const threadPlaceholders = Array.from(threadIdsToUpdate).map(() => "?").join(",");
         const threadUpdateQuery = `UPDATE ${threadsTableName} SET updatedAt = ? WHERE id IN (${threadPlaceholders})`;
         const threadUpdateParams = [(/* @__PURE__ */ new Date()).toISOString(), ...Array.from(threadIdsToUpdate)];
-        await this.operations.executeQuery({ sql: threadUpdateQuery, params: threadUpdateParams });
+        await this.#db.executeQuery({ sql: threadUpdateQuery, params: threadUpdateParams });
       }
-      const updatedMessages = await this.operations.executeQuery({ sql: selectQuery, params: messageIds });
+      const updatedMessages = await this.#db.executeQuery({ sql: selectQuery, params: messageIds });
       return updatedMessages.map((message) => {
         if (typeof message.content === "string") {
           try {
@@ -1170,7 +1414,7 @@ var MemoryStorageD1 = class extends MemoryStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_UPDATE_MESSAGES_FAILED",
+          id: createStorageErrorId("CLOUDFLARE_D1", "UPDATE_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: { count: messages.length }
@@ -1179,387 +1423,31 @@ var MemoryStorageD1 = class extends MemoryStorage {
       );
     }
   }
-};
-var StoreOperationsD1 = class extends StoreOperations {
-  client;
-  binding;
-  tablePrefix;
-  constructor(config) {
-    super();
-    this.client = config.client;
-    this.binding = config.binding;
-    this.tablePrefix = config.tablePrefix || "";
-  }
-  async hasColumn(table, column) {
-    const fullTableName = table.startsWith(this.tablePrefix) ? table : `${this.tablePrefix}${table}`;
-    const sql = `PRAGMA table_info(${fullTableName});`;
-    const result = await this.executeQuery({ sql, params: [] });
-    if (!result || !Array.isArray(result)) return false;
-    return result.some((col) => col.name === column || col.name === column.toLowerCase());
-  }
-  getTableName(tableName) {
-    return `${this.tablePrefix}${tableName}`;
-  }
-  formatSqlParams(params) {
-    return params.map((p) => p === void 0 || p === null ? null : p);
-  }
-  async executeWorkersBindingQuery({
-    sql,
-    params = [],
-    first = false
-  }) {
-    if (!this.binding) {
-      throw new Error("Workers binding is not configured");
-    }
-    try {
-      const statement = this.binding.prepare(sql);
-      const formattedParams = this.formatSqlParams(params);
-      let result;
-      if (formattedParams.length > 0) {
-        if (first) {
-          result = await statement.bind(...formattedParams).first();
-          if (!result) return null;
-          return result;
-        } else {
-          result = await statement.bind(...formattedParams).all();
-          const results = result.results || [];
-          return results;
-        }
-      } else {
-        if (first) {
-          result = await statement.first();
-          if (!result) return null;
-          return result;
-        } else {
-          result = await statement.all();
-          const results = result.results || [];
-          return results;
-        }
-      }
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_WORKERS_BINDING_QUERY_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { sql }
-        },
-        error
-      );
-    }
-  }
-  async executeRestQuery({
-    sql,
-    params = [],
-    first = false
-  }) {
-    if (!this.client) {
-      throw new Error("D1 client is not configured");
-    }
-    try {
-      const formattedParams = this.formatSqlParams(params);
-      const response = await this.client.query({
-        sql,
-        params: formattedParams
-      });
-      const result = response.result || [];
-      const results = result.flatMap((r) => r.results || []);
-      if (first) {
-        return results[0] || null;
-      }
-      return results;
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_REST_QUERY_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { sql }
-        },
-        error
-      );
-    }
-  }
-  async executeQuery(options) {
-    if (this.binding) {
-      return this.executeWorkersBindingQuery(options);
-    } else if (this.client) {
-      return this.executeRestQuery(options);
-    } else {
-      throw new Error("Neither binding nor client is configured");
-    }
-  }
-  async getTableColumns(tableName) {
-    try {
-      const sql = `PRAGMA table_info(${tableName})`;
-      const result = await this.executeQuery({ sql });
-      if (!result || !Array.isArray(result)) {
-        return [];
-      }
-      return result.map((row) => ({
-        name: row.name,
-        type: row.type
-      }));
-    } catch (error) {
-      this.logger.warn(`Failed to get table columns for ${tableName}:`, error);
-      return [];
-    }
-  }
-  serializeValue(value) {
-    if (value === null || value === void 0) {
-      return null;
-    }
-    if (value instanceof Date) {
-      return value.toISOString();
-    }
-    if (typeof value === "object") {
-      return JSON.stringify(value);
-    }
-    return value;
-  }
-  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 createTable({
-    tableName,
-    schema
-  }) {
-    try {
-      const fullTableName = this.getTableName(tableName);
-      const columnDefinitions = Object.entries(schema).map(([colName, colDef]) => {
-        const type = this.getSqlType(colDef.type);
-        const nullable = colDef.nullable === false ? "NOT NULL" : "";
-        const primaryKey = colDef.primaryKey ? "PRIMARY KEY" : "";
-        return `${colName} ${type} ${nullable} ${primaryKey}`.trim();
-      });
-      const tableConstraints = [];
-      if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
-        tableConstraints.push("UNIQUE (workflow_name, run_id)");
-      }
-      const query = createSqlBuilder().createTable(fullTableName, columnDefinitions, tableConstraints);
-      const { sql, params } = query.build();
-      await this.executeQuery({ sql, params });
-      this.logger.debug(`Created table ${fullTableName}`);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_CREATE_TABLE_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error
-      );
-    }
-  }
-  async clearTable({ tableName }) {
-    try {
-      const fullTableName = this.getTableName(tableName);
-      const query = createSqlBuilder().delete(fullTableName);
-      const { sql, params } = query.build();
-      await this.executeQuery({ sql, params });
-      this.logger.debug(`Cleared table ${fullTableName}`);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_CLEAR_TABLE_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error
-      );
-    }
-  }
-  async dropTable({ tableName }) {
-    try {
-      const fullTableName = this.getTableName(tableName);
-      const sql = `DROP TABLE IF EXISTS ${fullTableName}`;
-      await this.executeQuery({ sql });
-      this.logger.debug(`Dropped table ${fullTableName}`);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_DROP_TABLE_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error
-      );
-    }
-  }
-  async alterTable(args) {
-    try {
-      const fullTableName = this.getTableName(args.tableName);
-      const existingColumns = await this.getTableColumns(fullTableName);
-      const existingColumnNames = new Set(existingColumns.map((col) => col.name));
-      for (const [columnName, column] of Object.entries(args.schema)) {
-        if (!existingColumnNames.has(columnName) && args.ifNotExists.includes(columnName)) {
-          const sqlType = this.getSqlType(column.type);
-          const defaultValue = this.getDefaultValue(column.type);
-          const sql = `ALTER TABLE ${fullTableName} ADD COLUMN ${columnName} ${sqlType} ${defaultValue}`;
-          await this.executeQuery({ sql });
-          this.logger.debug(`Added column ${columnName} to table ${fullTableName}`);
-        }
-      }
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_ALTER_TABLE_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName: args.tableName }
-        },
-        error
-      );
-    }
-  }
-  async insert({ tableName, record }) {
-    try {
-      const fullTableName = this.getTableName(tableName);
-      const processedRecord = await this.processRecord(record);
-      const columns = Object.keys(processedRecord);
-      const values = Object.values(processedRecord);
-      const query = createSqlBuilder().insert(fullTableName, columns, values);
-      const { sql, params } = query.build();
-      await this.executeQuery({ sql, params });
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_INSERT_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error
-      );
-    }
-  }
-  async batchInsert({ tableName, records }) {
-    try {
-      if (records.length === 0) return;
-      const fullTableName = this.getTableName(tableName);
-      const processedRecords = await Promise.all(records.map((record) => this.processRecord(record)));
-      const columns = Object.keys(processedRecords[0] || {});
-      for (const record of processedRecords) {
-        const values = Object.values(record);
-        const query = createSqlBuilder().insert(fullTableName, columns, values);
-        const { sql, params } = query.build();
-        await this.executeQuery({ sql, params });
-      }
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_BATCH_INSERT_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error
-      );
-    }
-  }
-  async load({ tableName, keys }) {
-    try {
-      const fullTableName = this.getTableName(tableName);
-      const query = createSqlBuilder().select("*").from(fullTableName);
-      let firstKey = true;
-      for (const [key, value] of Object.entries(keys)) {
-        if (firstKey) {
-          query.where(`${key} = ?`, value);
-          firstKey = false;
-        } else {
-          query.andWhere(`${key} = ?`, value);
-        }
-      }
-      query.orderBy("createdAt", "DESC");
-      query.limit(1);
-      const { sql, params } = query.build();
-      const result = await this.executeQuery({ sql, params, first: true });
-      if (!result) {
-        return null;
-      }
-      const deserializedResult = {};
-      for (const [key, value] of Object.entries(result)) {
-        deserializedResult[key] = deserializeValue(value);
-      }
-      return deserializedResult;
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "CLOUDFLARE_D1_STORE_OPERATIONS_LOAD_FAILED",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { tableName }
-        },
-        error
-      );
-    }
-  }
-  async processRecord(record) {
-    const processed = {};
-    for (const [key, value] of Object.entries(record)) {
-      processed[key] = this.serializeValue(value);
-    }
-    return processed;
-  }
-  /**
-   * Upsert multiple records in a batch operation
-   * @param tableName The table to insert into
-   * @param records The records to insert
-   */
-  async batchUpsert({ tableName, records }) {
-    if (records.length === 0) return;
-    const fullTableName = this.getTableName(tableName);
+  async deleteMessages(messageIds) {
+    if (messageIds.length === 0) return;
+    const fullTableName = this.#db.getTableName(TABLE_MESSAGES);
+    const threadsTableName = this.#db.getTableName(TABLE_THREADS);
     try {
-      const batchSize = 50;
-      for (let i = 0; i < records.length; i += batchSize) {
-        const batch = records.slice(i, i + batchSize);
-        const recordsToInsert = batch;
-        if (recordsToInsert.length > 0) {
-          const firstRecord = recordsToInsert[0];
-          const columns = Object.keys(firstRecord || {});
-          for (const record of recordsToInsert) {
-            const values = columns.map((col) => {
-              if (!record) return null;
-              const value = typeof col === "string" ? record[col] : null;
-              return this.serializeValue(value);
-            });
-            const recordToUpsert = columns.reduce(
-              (acc, col) => {
-                if (col !== "createdAt") acc[col] = `excluded.${col}`;
-                return acc;
-              },
-              {}
-            );
-            const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], recordToUpsert);
-            const { sql, params } = query.build();
-            await this.executeQuery({ sql, params });
-          }
-        }
-        this.logger.debug(
-          `Processed batch ${Math.floor(i / batchSize) + 1} of ${Math.ceil(records.length / batchSize)}`
-        );
+      const placeholders = messageIds.map(() => "?").join(",");
+      const selectQuery = `SELECT DISTINCT thread_id FROM ${fullTableName} WHERE id IN (${placeholders})`;
+      const threadResults = await this.#db.executeQuery({ sql: selectQuery, params: messageIds });
+      const threadIds = threadResults.map((r) => r.thread_id).filter(Boolean);
+      const deleteQuery = createSqlBuilder().delete(fullTableName).where(`id IN (${placeholders})`, ...messageIds);
+      const { sql, params } = deleteQuery.build();
+      await this.#db.executeQuery({ sql, params });
+      if (threadIds.length > 0) {
+        const threadPlaceholders = threadIds.map(() => "?").join(",");
+        const threadUpdateQuery = `UPDATE ${threadsTableName} SET updatedAt = ? WHERE id IN (${threadPlaceholders})`;
+        const threadUpdateParams = [(/* @__PURE__ */ new Date()).toISOString(), ...threadIds];
+        await this.#db.executeQuery({ sql: threadUpdateQuery, params: threadUpdateParams });
       }
-      this.logger.debug(`Successfully batch upserted ${records.length} records into ${tableName}`);
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_BATCH_UPSERT_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "DELETE_MESSAGES", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          text: `Failed to batch upsert into ${tableName}: ${error instanceof Error ? error.message : String(error)}`,
-          details: { tableName }
+          details: { messageIds: JSON.stringify(messageIds) }
         },
         error
       );
@@ -1567,32 +1455,31 @@ var StoreOperationsD1 = class extends StoreOperations {
   }
 };
 function transformScoreRow(row) {
-  const deserialized = { ...row };
-  deserialized.input = safelyParseJSON(row.input);
-  deserialized.output = safelyParseJSON(row.output);
-  deserialized.scorer = safelyParseJSON(row.scorer);
-  deserialized.preprocessStepResult = safelyParseJSON(row.preprocessStepResult);
-  deserialized.analyzeStepResult = safelyParseJSON(row.analyzeStepResult);
-  deserialized.metadata = safelyParseJSON(row.metadata);
-  deserialized.additionalContext = safelyParseJSON(row.additionalContext);
-  deserialized.runtimeContext = safelyParseJSON(row.runtimeContext);
-  deserialized.entity = safelyParseJSON(row.entity);
-  deserialized.createdAt = row.createdAtZ || row.createdAt;
-  deserialized.updatedAt = row.updatedAtZ || row.updatedAt;
-  return deserialized;
+  return transformScoreRow$1(row, {
+    preferredTimestampFields: {
+      createdAt: "createdAtZ",
+      updatedAt: "updatedAtZ"
+    }
+  });
 }
 var ScoresStorageD1 = class extends ScoresStorage {
-  operations;
-  constructor({ operations }) {
+  #db;
+  constructor(config) {
     super();
-    this.operations = operations;
+    this.#db = new D1DB(resolveD1Config(config));
+  }
+  async init() {
+    await this.#db.createTable({ tableName: TABLE_SCORERS, schema: TABLE_SCHEMAS[TABLE_SCORERS] });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: TABLE_SCORERS });
   }
   async getScoreById({ id }) {
     try {
-      const fullTableName = this.operations.getTableName(TABLE_SCORERS);
+      const fullTableName = this.#db.getTableName(TABLE_SCORERS);
       const query = createSqlBuilder().select("*").from(fullTableName).where("id = ?", id);
       const { sql, params } = query.build();
-      const result = await this.operations.executeQuery({ sql, params, first: true });
+      const result = await this.#db.executeQuery({ sql, params, first: true });
       if (!result) {
         return null;
       }
@@ -1600,7 +1487,7 @@ var ScoresStorageD1 = class extends ScoresStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_SCORES_GET_SCORE_BY_ID_FAILED",
+          id: createStorageErrorId("CLOUDFLARE_D1", "GET_SCORE_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY
         },
@@ -1609,12 +1496,31 @@ var ScoresStorageD1 = class extends ScoresStorage {
     }
   }
   async saveScore(score) {
+    let parsedScore;
+    try {
+      parsedScore = saveScorePayloadSchema.parse(score);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_D1", "SAVE_SCORE", "VALIDATION_FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: {
+            scorer: typeof score.scorer?.id === "string" ? score.scorer.id : String(score.scorer?.id ?? "unknown"),
+            entityId: score.entityId ?? "unknown",
+            entityType: score.entityType ?? "unknown",
+            traceId: score.traceId ?? "",
+            spanId: score.spanId ?? ""
+          }
+        },
+        error
+      );
+    }
+    const id = crypto.randomUUID();
     try {
-      const id = crypto.randomUUID();
-      const fullTableName = this.operations.getTableName(TABLE_SCORERS);
-      const { input, ...rest } = score;
+      const fullTableName = this.#db.getTableName(TABLE_SCORERS);
       const serializedRecord = {};
-      for (const [key, value] of Object.entries(rest)) {
+      for (const [key, value] of Object.entries(parsedScore)) {
         if (value !== null && value !== void 0) {
           if (typeof value === "object") {
             serializedRecord[key] = JSON.stringify(value);
@@ -1625,29 +1531,29 @@ var ScoresStorageD1 = class extends ScoresStorage {
           serializedRecord[key] = null;
         }
       }
+      const now = /* @__PURE__ */ new Date();
       serializedRecord.id = id;
-      serializedRecord.input = JSON.stringify(input);
-      serializedRecord.createdAt = (/* @__PURE__ */ new Date()).toISOString();
-      serializedRecord.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      serializedRecord.createdAt = now.toISOString();
+      serializedRecord.updatedAt = now.toISOString();
       const columns = Object.keys(serializedRecord);
       const values = Object.values(serializedRecord);
       const query = createSqlBuilder().insert(fullTableName, columns, values);
       const { sql, params } = query.build();
-      await this.operations.executeQuery({ sql, params });
-      const scoreFromDb = await this.getScoreById({ id });
-      return { score: scoreFromDb };
+      await this.#db.executeQuery({ sql, params });
+      return { score: { ...parsedScore, id, createdAt: now, updatedAt: now } };
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_SCORES_SAVE_SCORE_FAILED",
+          id: createStorageErrorId("CLOUDFLARE_D1", "SAVE_SCORE", "FAILED"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id }
         },
         error
       );
     }
   }
-  async getScoresByScorerId({
+  async listScoresByScorerId({
     scorerId,
     entityId,
     entityType,
@@ -1655,7 +1561,10 @@ var ScoresStorageD1 = class extends ScoresStorage {
     pagination
   }) {
     try {
-      const fullTableName = this.operations.getTableName(TABLE_SCORERS);
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+      const fullTableName = this.#db.getTableName(TABLE_SCORERS);
       const countQuery = createSqlBuilder().count().from(fullTableName).where("scorerId = ?", scorerId);
       if (entityId) {
         countQuery.andWhere("entityId = ?", entityId);
@@ -1666,19 +1575,21 @@ var ScoresStorageD1 = class extends ScoresStorage {
       if (source) {
         countQuery.andWhere("source = ?", source);
       }
-      const countResult = await this.operations.executeQuery(countQuery.build());
+      const countResult = await this.#db.executeQuery(countQuery.build());
       const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
       if (total === 0) {
         return {
           pagination: {
             total: 0,
-            page: pagination.page,
-            perPage: pagination.perPage,
+            page,
+            perPage: perPageForResponse,
             hasMore: false
           },
           scores: []
         };
       }
+      const end = perPageInput === false ? total : start + perPage;
+      const limitValue = perPageInput === false ? total : perPage;
       const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("scorerId = ?", scorerId);
       if (entityId) {
         selectQuery.andWhere("entityId = ?", entityId);
@@ -1689,23 +1600,23 @@ var ScoresStorageD1 = class extends ScoresStorage {
       if (source) {
         selectQuery.andWhere("source = ?", source);
       }
-      selectQuery.limit(pagination.perPage).offset(pagination.page * pagination.perPage);
+      selectQuery.limit(limitValue).offset(start);
       const { sql, params } = selectQuery.build();
-      const results = await this.operations.executeQuery({ sql, params });
+      const results = await this.#db.executeQuery({ sql, params });
       const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
       return {
         pagination: {
           total,
-          page: pagination.page,
-          perPage: pagination.perPage,
-          hasMore: total > (pagination.page + 1) * pagination.perPage
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
         },
         scores
       };
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_SCORES_GET_SCORES_BY_SCORER_ID_FAILED",
+          id: createStorageErrorId("CLOUDFLARE_D1", "GET_SCORES_BY_SCORER_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY
         },
@@ -1713,43 +1624,48 @@ var ScoresStorageD1 = class extends ScoresStorage {
       );
     }
   }
-  async getScoresByRunId({
+  async listScoresByRunId({
     runId,
     pagination
   }) {
     try {
-      const fullTableName = this.operations.getTableName(TABLE_SCORERS);
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+      const fullTableName = this.#db.getTableName(TABLE_SCORERS);
       const countQuery = createSqlBuilder().count().from(fullTableName).where("runId = ?", runId);
-      const countResult = await this.operations.executeQuery(countQuery.build());
+      const countResult = await this.#db.executeQuery(countQuery.build());
       const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
       if (total === 0) {
         return {
           pagination: {
             total: 0,
-            page: pagination.page,
-            perPage: pagination.perPage,
+            page,
+            perPage: perPageForResponse,
             hasMore: false
           },
           scores: []
         };
       }
-      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("runId = ?", runId).limit(pagination.perPage).offset(pagination.page * pagination.perPage);
+      const end = perPageInput === false ? total : start + perPage;
+      const limitValue = perPageInput === false ? total : perPage;
+      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("runId = ?", runId).limit(limitValue).offset(start);
       const { sql, params } = selectQuery.build();
-      const results = await this.operations.executeQuery({ sql, params });
+      const results = await this.#db.executeQuery({ sql, params });
       const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
       return {
         pagination: {
           total,
-          page: pagination.page,
-          perPage: pagination.perPage,
-          hasMore: total > (pagination.page + 1) * pagination.perPage
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
         },
         scores
       };
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_SCORES_GET_SCORES_BY_RUN_ID_FAILED",
+          id: createStorageErrorId("CLOUDFLARE_D1", "GET_SCORES_BY_RUN_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY
         },
@@ -1757,44 +1673,49 @@ var ScoresStorageD1 = class extends ScoresStorage {
       );
     }
   }
-  async getScoresByEntityId({
+  async listScoresByEntityId({
     entityId,
     entityType,
     pagination
   }) {
     try {
-      const fullTableName = this.operations.getTableName(TABLE_SCORERS);
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+      const fullTableName = this.#db.getTableName(TABLE_SCORERS);
       const countQuery = createSqlBuilder().count().from(fullTableName).where("entityId = ?", entityId).andWhere("entityType = ?", entityType);
-      const countResult = await this.operations.executeQuery(countQuery.build());
+      const countResult = await this.#db.executeQuery(countQuery.build());
       const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
       if (total === 0) {
         return {
           pagination: {
             total: 0,
-            page: pagination.page,
-            perPage: pagination.perPage,
+            page,
+            perPage: perPageForResponse,
             hasMore: false
           },
           scores: []
         };
       }
-      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("entityId = ?", entityId).andWhere("entityType = ?", entityType).limit(pagination.perPage).offset(pagination.page * pagination.perPage);
+      const end = perPageInput === false ? total : start + perPage;
+      const limitValue = perPageInput === false ? total : perPage;
+      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("entityId = ?", entityId).andWhere("entityType = ?", entityType).limit(limitValue).offset(start);
       const { sql, params } = selectQuery.build();
-      const results = await this.operations.executeQuery({ sql, params });
+      const results = await this.#db.executeQuery({ sql, params });
       const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
       return {
         pagination: {
           total,
-          page: pagination.page,
-          perPage: pagination.perPage,
-          hasMore: total > (pagination.page + 1) * pagination.perPage
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
         },
         scores
       };
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORE_SCORES_GET_SCORES_BY_ENTITY_ID_FAILED",
+          id: createStorageErrorId("CLOUDFLARE_D1", "GET_SCORES_BY_ENTITY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY
         },
@@ -1802,141 +1723,75 @@ var ScoresStorageD1 = class extends ScoresStorage {
       );
     }
   }
-};
-function isArrayOfRecords2(value) {
-  return value && Array.isArray(value) && value.length > 0;
-}
-var TracesStorageD1 = class extends TracesStorage {
-  operations;
-  constructor({ operations }) {
-    super();
-    this.operations = operations;
-  }
-  async getTraces(args) {
-    const paginatedArgs = {
-      name: args.name,
-      scope: args.scope,
-      page: args.page,
-      perPage: args.perPage,
-      attributes: args.attributes,
-      filters: args.filters,
-      dateRange: args.fromDate || args.toDate ? {
-        start: args.fromDate,
-        end: args.toDate
-      } : void 0
-    };
-    try {
-      const result = await this.getTracesPaginated(paginatedArgs);
-      return result.traces;
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: "CLOUDFLARE_D1_STORAGE_GET_TRACES_ERROR",
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          text: `Failed to retrieve traces: ${error instanceof Error ? error.message : String(error)}`,
-          details: {
-            name: args.name ?? "",
-            scope: args.scope ?? ""
-          }
-        },
-        error
-      );
-    }
-  }
-  async getTracesPaginated(args) {
-    const { name, scope, page = 0, perPage = 100, attributes, dateRange } = args;
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-    const fullTableName = this.operations.getTableName(TABLE_TRACES);
+  async listScoresBySpan({
+    traceId,
+    spanId,
+    pagination
+  }) {
     try {
-      const dataQuery = createSqlBuilder().select("*").from(fullTableName).where("1=1");
-      const countQuery = createSqlBuilder().count().from(fullTableName).where("1=1");
-      if (name) {
-        dataQuery.andWhere("name LIKE ?", `%${name}%`);
-        countQuery.andWhere("name LIKE ?", `%${name}%`);
-      }
-      if (scope) {
-        dataQuery.andWhere("scope = ?", scope);
-        countQuery.andWhere("scope = ?", scope);
-      }
-      if (attributes && Object.keys(attributes).length > 0) {
-        for (const [key, value] of Object.entries(attributes)) {
-          dataQuery.jsonLike("attributes", key, value);
-          countQuery.jsonLike("attributes", key, value);
-        }
-      }
-      if (fromDate) {
-        const fromDateStr = fromDate instanceof Date ? fromDate.toISOString() : fromDate;
-        dataQuery.andWhere("createdAt >= ?", fromDateStr);
-        countQuery.andWhere("createdAt >= ?", fromDateStr);
-      }
-      if (toDate) {
-        const toDateStr = toDate instanceof Date ? toDate.toISOString() : toDate;
-        dataQuery.andWhere("createdAt <= ?", toDateStr);
-        countQuery.andWhere("createdAt <= ?", toDateStr);
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+      const fullTableName = this.#db.getTableName(TABLE_SCORERS);
+      const countQuery = createSqlBuilder().count().from(fullTableName).where("traceId = ?", traceId).andWhere("spanId = ?", spanId);
+      const countResult = await this.#db.executeQuery(countQuery.build());
+      const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
+      if (total === 0) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageForResponse,
+            hasMore: false
+          },
+          scores: []
+        };
       }
-      const allDataResult = await this.operations.executeQuery(
-        createSqlBuilder().select("*").from(fullTableName).where("1=1").build()
-      );
-      console.log("allDataResult", allDataResult);
-      const countResult = await this.operations.executeQuery(countQuery.build());
-      const total = Number(countResult?.[0]?.count ?? 0);
-      dataQuery.orderBy("startTime", "DESC").limit(perPage).offset(page * perPage);
-      const results = await this.operations.executeQuery(dataQuery.build());
-      const traces = isArrayOfRecords2(results) ? results.map(
-        (trace) => ({
-          ...trace,
-          attributes: deserializeValue(trace.attributes, "jsonb"),
-          status: deserializeValue(trace.status, "jsonb"),
-          events: deserializeValue(trace.events, "jsonb"),
-          links: deserializeValue(trace.links, "jsonb"),
-          other: deserializeValue(trace.other, "jsonb")
-        })
-      ) : [];
+      const end = perPageInput === false ? total : start + perPage;
+      const limitValue = perPageInput === false ? total : perPage;
+      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("traceId = ?", traceId).andWhere("spanId = ?", spanId).orderBy("createdAt", "DESC").limit(limitValue).offset(start);
+      const { sql, params } = selectQuery.build();
+      const results = await this.#db.executeQuery({ sql, params });
+      const scores = Array.isArray(results) ? results.map(transformScoreRow) : [];
       return {
-        traces,
-        total,
-        page,
-        perPage,
-        hasMore: page * perPage + traces.length < total
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        },
+        scores
       };
     } catch (error) {
-      const mastraError = new MastraError(
+      throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_TRACES_PAGINATED_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "GET_SCORES_BY_SPAN", "FAILED"),
           domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          text: `Failed to retrieve traces: ${error instanceof Error ? error.message : String(error)}`,
-          details: { name: name ?? "", scope: scope ?? "" }
+          category: ErrorCategory.THIRD_PARTY
         },
         error
       );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return { traces: [], total: 0, page, perPage, hasMore: false };
     }
   }
-  async batchTraceInsert({ records }) {
-    this.logger.debug("Batch inserting traces", { count: records.length });
-    await this.operations.batchInsert({
-      tableName: TABLE_TRACES,
-      records
-    });
-  }
 };
 var WorkflowsStorageD1 = class extends WorkflowsStorage {
-  operations;
-  constructor({ operations }) {
+  #db;
+  constructor(config) {
     super();
-    this.operations = operations;
+    this.#db = new D1DB(resolveD1Config(config));
+  }
+  async init() {
+    await this.#db.createTable({ tableName: TABLE_WORKFLOW_SNAPSHOT, schema: TABLE_SCHEMAS[TABLE_WORKFLOW_SNAPSHOT] });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: TABLE_WORKFLOW_SNAPSHOT });
   }
   updateWorkflowResults({
     // workflowName,
     // runId,
     // stepId,
     // result,
-    // runtimeContext,
+    // requestContext,
   }) {
     throw new Error("Method not implemented.");
   }
@@ -1950,26 +1805,31 @@ var WorkflowsStorageD1 = class extends WorkflowsStorage {
   async persistWorkflowSnapshot({
     workflowName,
     runId,
-    snapshot
+    resourceId,
+    snapshot,
+    createdAt,
+    updatedAt
   }) {
-    const fullTableName = this.operations.getTableName(TABLE_WORKFLOW_SNAPSHOT);
+    const fullTableName = this.#db.getTableName(TABLE_WORKFLOW_SNAPSHOT);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const currentSnapshot = await this.operations.load({
+    const currentSnapshot = await this.#db.load({
       tableName: TABLE_WORKFLOW_SNAPSHOT,
       keys: { workflow_name: workflowName, run_id: runId }
     });
     const persisting = currentSnapshot ? {
       ...currentSnapshot,
+      resourceId,
       snapshot: JSON.stringify(snapshot),
-      updatedAt: now
+      updatedAt: updatedAt ? updatedAt.toISOString() : now
     } : {
       workflow_name: workflowName,
       run_id: runId,
+      resourceId,
       snapshot,
-      createdAt: now,
-      updatedAt: now
+      createdAt: createdAt ? createdAt.toISOString() : now,
+      updatedAt: updatedAt ? updatedAt.toISOString() : now
     };
-    const processedRecord = await this.operations.processRecord(persisting);
+    const processedRecord = await this.#db.processRecord(persisting);
     const columns = Object.keys(processedRecord);
     const values = Object.values(processedRecord);
     const updateMap = {
@@ -1980,11 +1840,11 @@ var WorkflowsStorageD1 = class extends WorkflowsStorage {
     const query = createSqlBuilder().insert(fullTableName, columns, values, ["workflow_name", "run_id"], updateMap);
     const { sql, params } = query.build();
     try {
-      await this.operations.executeQuery({ sql, params });
+      await this.#db.executeQuery({ sql, params });
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_PERSIST_WORKFLOW_SNAPSHOT_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           text: `Failed to persist workflow snapshot: ${error instanceof Error ? error.message : String(error)}`,
@@ -1998,7 +1858,7 @@ var WorkflowsStorageD1 = class extends WorkflowsStorage {
     const { workflowName, runId } = params;
     this.logger.debug("Loading workflow snapshot", { workflowName, runId });
     try {
-      const d = await this.operations.load({
+      const d = await this.#db.load({
         tableName: TABLE_WORKFLOW_SNAPSHOT,
         keys: {
           workflow_name: workflowName,
@@ -2009,7 +1869,7 @@ var WorkflowsStorageD1 = class extends WorkflowsStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_LOAD_WORKFLOW_SNAPSHOT_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "LOAD_WORKFLOW_SNAPSHOT", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           text: `Failed to load workflow snapshot: ${error instanceof Error ? error.message : String(error)}`,
@@ -2037,21 +1897,26 @@ var WorkflowsStorageD1 = class extends WorkflowsStorage {
       resourceId: row.resourceId
     };
   }
-  async getWorkflowRuns({
+  async listWorkflowRuns({
     workflowName,
     fromDate,
     toDate,
-    limit,
-    offset,
-    resourceId
+    page,
+    perPage,
+    resourceId,
+    status
   } = {}) {
-    const fullTableName = this.operations.getTableName(TABLE_WORKFLOW_SNAPSHOT);
+    const fullTableName = this.#db.getTableName(TABLE_WORKFLOW_SNAPSHOT);
     try {
       const builder = createSqlBuilder().select().from(fullTableName);
       const countBuilder = createSqlBuilder().count().from(fullTableName);
       if (workflowName) builder.whereAnd("workflow_name = ?", workflowName);
+      if (status) {
+        builder.whereAnd("json_extract(snapshot, '$.status') = ?", status);
+        countBuilder.whereAnd("json_extract(snapshot, '$.status') = ?", status);
+      }
       if (resourceId) {
-        const hasResourceId = await this.operations.hasColumn(fullTableName, "resourceId");
+        const hasResourceId = await this.#db.hasColumn(fullTableName, "resourceId");
         if (hasResourceId) {
           builder.whereAnd("resourceId = ?", resourceId);
           countBuilder.whereAnd("resourceId = ?", resourceId);
@@ -2068,26 +1933,29 @@ var WorkflowsStorageD1 = class extends WorkflowsStorage {
         countBuilder.whereAnd("createdAt <= ?", toDate instanceof Date ? toDate.toISOString() : toDate);
       }
       builder.orderBy("createdAt", "DESC");
-      if (typeof limit === "number") builder.limit(limit);
-      if (typeof offset === "number") builder.offset(offset);
+      if (typeof perPage === "number" && typeof page === "number") {
+        const offset = page * perPage;
+        builder.limit(perPage);
+        builder.offset(offset);
+      }
       const { sql, params } = builder.build();
       let total = 0;
-      if (limit !== void 0 && offset !== void 0) {
+      if (perPage !== void 0 && page !== void 0) {
         const { sql: countSql, params: countParams } = countBuilder.build();
-        const countResult = await this.operations.executeQuery({
+        const countResult = await this.#db.executeQuery({
           sql: countSql,
           params: countParams,
           first: true
         });
         total = Number(countResult?.count ?? 0);
       }
-      const results = await this.operations.executeQuery({ sql, params });
+      const results = await this.#db.executeQuery({ sql, params });
       const runs = (isArrayOfRecords(results) ? results : []).map((row) => this.parseWorkflowRun(row));
       return { runs, total: total || runs.length };
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_WORKFLOW_RUNS_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "LIST_WORKFLOW_RUNS", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           text: `Failed to retrieve workflow runs: ${error instanceof Error ? error.message : String(error)}`,
@@ -2104,7 +1972,7 @@ var WorkflowsStorageD1 = class extends WorkflowsStorage {
     runId,
     workflowName
   }) {
-    const fullTableName = this.operations.getTableName(TABLE_WORKFLOW_SNAPSHOT);
+    const fullTableName = this.#db.getTableName(TABLE_WORKFLOW_SNAPSHOT);
     try {
       const conditions = [];
       const params = [];
@@ -2118,13 +1986,13 @@ var WorkflowsStorageD1 = class extends WorkflowsStorage {
       }
       const whereClause = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
       const sql = `SELECT * FROM ${fullTableName} ${whereClause} ORDER BY createdAt DESC LIMIT 1`;
-      const result = await this.operations.executeQuery({ sql, params, first: true });
+      const result = await this.#db.executeQuery({ sql, params, first: true });
       if (!result) return null;
       return this.parseWorkflowRun(result);
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_WORKFLOW_RUN_BY_ID_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           text: `Failed to retrieve workflow run by ID: ${error instanceof Error ? error.message : String(error)}`,
@@ -2134,13 +2002,31 @@ var WorkflowsStorageD1 = class extends WorkflowsStorage {
       );
     }
   }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    const fullTableName = this.#db.getTableName(TABLE_WORKFLOW_SNAPSHOT);
+    try {
+      const sql = `DELETE FROM ${fullTableName} WHERE workflow_name = ? AND run_id = ?`;
+      const params = [workflowName, runId];
+      await this.#db.executeQuery({ sql, params });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_D1", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to delete workflow run by ID: ${error instanceof Error ? error.message : String(error)}`,
+          details: { runId, workflowName }
+        },
+        error
+      );
+    }
+  }
 };
 
 // src/storage/index.ts
 var D1Store = class extends MastraStorage {
   client;
   binding;
-  // D1Database binding
   tablePrefix;
   stores;
   /**
@@ -2149,7 +2035,7 @@ var D1Store = class extends MastraStorage {
    */
   constructor(config) {
     try {
-      super({ name: "D1" });
+      super({ id: config.id, name: "D1", disableInit: config.disableInit });
       if (config.tablePrefix && !/^[a-zA-Z0-9_]*$/.test(config.tablePrefix)) {
         throw new Error("Invalid tablePrefix: only letters, numbers, and underscores are allowed.");
       }
@@ -2187,7 +2073,7 @@ var D1Store = class extends MastraStorage {
     } catch (error) {
       throw new MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_INITIALIZATION_ERROR",
+          id: createStorageErrorId("CLOUDFLARE_D1", "INITIALIZATION", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.SYSTEM,
           text: "Error initializing D1Store"
@@ -2195,242 +2081,26 @@ var D1Store = class extends MastraStorage {
         error
       );
     }
-    const operations = new StoreOperationsD1({
-      client: this.client,
-      binding: this.binding,
-      tablePrefix: this.tablePrefix
-    });
-    const scores = new ScoresStorageD1({
-      operations
-    });
-    const legacyEvals = new LegacyEvalsStorageD1({
-      operations
-    });
-    const traces = new TracesStorageD1({
-      operations
-    });
-    const workflows = new WorkflowsStorageD1({
-      operations
-    });
-    const memory = new MemoryStorageD1({
-      operations
-    });
+    let scores;
+    let workflows;
+    let memory;
+    if (this.binding) {
+      const domainConfig = { binding: this.binding, tablePrefix: this.tablePrefix };
+      scores = new ScoresStorageD1(domainConfig);
+      workflows = new WorkflowsStorageD1(domainConfig);
+      memory = new MemoryStorageD1(domainConfig);
+    } else {
+      const domainConfig = { client: this.client, tablePrefix: this.tablePrefix };
+      scores = new ScoresStorageD1(domainConfig);
+      workflows = new WorkflowsStorageD1(domainConfig);
+      memory = new MemoryStorageD1(domainConfig);
+    }
     this.stores = {
-      operations,
       scores,
-      legacyEvals,
-      traces,
       workflows,
       memory
     };
   }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true,
-      hasColumn: true,
-      createTable: true,
-      deleteMessages: false
-    };
-  }
-  async createTable({
-    tableName,
-    schema
-  }) {
-    return 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
-  }) {
-    return this.stores.operations.alterTable({ tableName, schema, ifNotExists });
-  }
-  async clearTable({ tableName }) {
-    return this.stores.operations.clearTable({ tableName });
-  }
-  async dropTable({ tableName }) {
-    return this.stores.operations.dropTable({ tableName });
-  }
-  async hasColumn(table, column) {
-    return this.stores.operations.hasColumn(table, column);
-  }
-  async insert({ tableName, record }) {
-    return this.stores.operations.insert({ tableName, record });
-  }
-  async load({ tableName, keys }) {
-    return this.stores.operations.load({ tableName, keys });
-  }
-  async getThreadById({ threadId }) {
-    return this.stores.memory.getThreadById({ threadId });
-  }
-  /**
-   * @deprecated use getThreadsByResourceIdPaginated instead
-   */
-  async getThreadsByResourceId({ resourceId }) {
-    return this.stores.memory.getThreadsByResourceId({ resourceId });
-  }
-  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 saveMessages(args) {
-    return this.stores.memory.saveMessages(args);
-  }
-  async getMessages({
-    threadId,
-    selectBy,
-    format
-  }) {
-    return this.stores.memory.getMessages({ threadId, selectBy, format });
-  }
-  async getMessagesById({
-    messageIds,
-    format
-  }) {
-    return this.stores.memory.getMessagesById({ messageIds, format });
-  }
-  async getMessagesPaginated({
-    threadId,
-    selectBy,
-    format
-  }) {
-    return this.stores.memory.getMessagesPaginated({ threadId, selectBy, format });
-  }
-  async updateWorkflowResults({
-    workflowName,
-    runId,
-    stepId,
-    result,
-    runtimeContext
-  }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, runtimeContext });
-  }
-  async updateWorkflowState({
-    workflowName,
-    runId,
-    opts
-  }) {
-    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
-  }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    snapshot
-  }) {
-    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
-  }
-  async loadWorkflowSnapshot(params) {
-    return this.stores.workflows.loadWorkflowSnapshot(params);
-  }
-  async getWorkflowRuns({
-    workflowName,
-    fromDate,
-    toDate,
-    limit,
-    offset,
-    resourceId
-  } = {}) {
-    return this.stores.workflows.getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId });
-  }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
-    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
-  }
-  /**
-   * Insert multiple records in a batch operation
-   * @param tableName The table to insert into
-   * @param records The records to insert
-   */
-  async batchInsert({ tableName, records }) {
-    return this.stores.operations.batchInsert({ tableName, records });
-  }
-  /**
-   * @deprecated use getTracesPaginated instead
-   */
-  async getTraces(args) {
-    return this.stores.traces.getTraces(args);
-  }
-  async getTracesPaginated(args) {
-    return this.stores.traces.getTracesPaginated(args);
-  }
-  /**
-   * @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 updateMessages(_args) {
-    return this.stores.memory.updateMessages(_args);
-  }
-  async getResourceById({ resourceId }) {
-    return this.stores.memory.getResourceById({ resourceId });
-  }
-  async saveResource({ resource }) {
-    return this.stores.memory.saveResource({ resource });
-  }
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata
-  }) {
-    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
-  }
-  async getScoreById({ id: _id }) {
-    return this.stores.scores.getScoreById({ id: _id });
-  }
-  async saveScore(_score) {
-    return this.stores.scores.saveScore(_score);
-  }
-  async getScoresByRunId({
-    runId: _runId,
-    pagination: _pagination
-  }) {
-    return this.stores.scores.getScoresByRunId({ runId: _runId, pagination: _pagination });
-  }
-  async getScoresByEntityId({
-    entityId: _entityId,
-    entityType: _entityType,
-    pagination: _pagination
-  }) {
-    return this.stores.scores.getScoresByEntityId({
-      entityId: _entityId,
-      entityType: _entityType,
-      pagination: _pagination
-    });
-  }
-  async getScoresByScorerId({
-    scorerId,
-    pagination,
-    entityId,
-    entityType,
-    source
-  }) {
-    return this.stores.scores.getScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
-  }
   /**
    * Close the database connection
    * No explicit cleanup needed for D1 in either REST or Workers Binding mode
@@ -2440,6 +2110,6 @@ var D1Store = class extends MastraStorage {
   }
 };
 
-export { D1Store };
+export { D1Store, MemoryStorageD1, ScoresStorageD1, WorkflowsStorageD1 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map