@mastra/cloudflare-d1 0.0.0-tsconfig-compile-20250703214351 → 0.0.0-unified-sidebar-20251010130811

package/dist/index.cjs

@@ -1,10 +1,11 @@
 'use strict';
 
-var agent = require('@mastra/core/agent');
 var error = require('@mastra/core/error');
 var storage = require('@mastra/core/storage');
 var Cloudflare = require('cloudflare');
 var utils = require('@mastra/core/utils');
+var agent = require('@mastra/core/agent');
+var scores = require('@mastra/core/scores');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -241,392 +242,301 @@ function parseSelectIdentifier(column) {
   return column;
 }
 
-// src/storage/index.ts
+// src/storage/domains/utils.ts
 function isArrayOfRecords(value) {
   return value && Array.isArray(value) && value.length > 0;
 }
-var D1Store = class extends storage.MastraStorage {
-  client;
-  accountId;
-  databaseId;
-  binding;
-  // D1Database binding
-  tablePrefix;
-  /**
-   * Creates a new D1Store instance
-   * @param config Configuration for D1 access (either REST API or Workers Binding API)
-   */
-  constructor(config) {
-    try {
-      super({ name: "D1" });
-      if (config.tablePrefix && !/^[a-zA-Z0-9_]*$/.test(config.tablePrefix)) {
-        throw new Error("Invalid tablePrefix: only letters, numbers, and underscores are allowed.");
-      }
-      this.tablePrefix = config.tablePrefix || "";
-      if ("binding" in config) {
-        if (!config.binding) {
-          throw new Error("D1 binding is required when using Workers Binding API");
-        }
-        this.binding = config.binding;
-        this.logger.info("Using D1 Workers Binding API");
-      } else {
-        if (!config.accountId || !config.databaseId || !config.apiToken) {
-          throw new Error("accountId, databaseId, and apiToken are required when using REST API");
-        }
-        this.accountId = config.accountId;
-        this.databaseId = config.databaseId;
-        this.client = new Cloudflare__default.default({
-          apiToken: config.apiToken
-        });
-        this.logger.info("Using D1 REST API");
-      }
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "CLOUDFLARE_D1_STORAGE_INITIALIZATION_ERROR",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.SYSTEM,
-          text: "Error initializing D1Store"
-        },
-        error$1
-      );
-    }
-  }
-  // Helper method to get the full table name with prefix
-  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 || [];
-          if (result.meta) {
-            this.logger.debug("Query metadata", { meta: result.meta });
-          }
-          return results;
-        }
-      } else {
-        if (first) {
-          result = await statement.first();
-          if (!result) return null;
-          return result;
-        } else {
-          result = await statement.all();
-          const results = result.results || [];
-          if (result.meta) {
-            this.logger.debug("Query metadata", { meta: result.meta });
-          }
-          return results;
-        }
-      }
-    } catch (workerError) {
-      this.logger.error("Workers Binding API error", {
-        message: workerError instanceof Error ? workerError.message : String(workerError),
-        sql
-      });
-      throw new Error(`D1 Workers API error: ${workerError.message}`);
-    }
-  }
-  async executeRestQuery({
-    sql,
-    params = [],
-    first = false
-  }) {
-    if (!this.client || !this.accountId || !this.databaseId) {
-      throw new Error("Missing required REST API configuration");
-    }
-    try {
-      const response = await this.client.d1.database.query(this.databaseId, {
-        account_id: this.accountId,
-        sql,
-        params: this.formatSqlParams(params)
-      });
-      const result = response.result || [];
-      const results = result.flatMap((r) => r.results || []);
-      if (first) {
-        const firstResult = isArrayOfRecords(results) && results.length > 0 ? results[0] : null;
-        if (!firstResult) return null;
-        return firstResult;
-      }
-      return results;
-    } catch (restError) {
-      this.logger.error("REST API error", {
-        message: restError instanceof Error ? restError.message : String(restError),
-        sql
-      });
-      throw new Error(`D1 REST API error: ${restError.message}`);
-    }
+function deserializeValue(value, type) {
+  if (value === null || value === void 0) return null;
+  if (type === "date" && typeof value === "string") {
+    return new Date(value);
   }
-  /**
-   * Execute a SQL query against the D1 database
-   * @param options Query options including SQL, parameters, and whether to return only the first result
-   * @returns Query results as an array or a single object if first=true
-   */
-  async executeQuery(options) {
-    const { sql, params = [], first = false } = options;
+  if (type === "jsonb" && typeof value === "string") {
     try {
-      this.logger.debug("Executing SQL query", { sql, params, first });
-      if (this.binding) {
-        return this.executeWorkersBindingQuery({ sql, params, first });
-      } else if (this.client && this.accountId && this.databaseId) {
-        return this.executeRestQuery({ sql, params, first });
-      } else {
-        throw new Error("No valid D1 configuration provided");
-      }
-    } catch (error) {
-      this.logger.error("Error executing SQL query", {
-        message: error instanceof Error ? error.message : String(error),
-        sql,
-        params,
-        first
-      });
-      throw new Error(`D1 query error: ${error.message}`);
+      return JSON.parse(value);
+    } catch {
+      return value;
     }
   }
-  // Helper to get existing table columns
-  async getTableColumns(tableName) {
+  if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
     try {
-      const sql = `PRAGMA table_info(${tableName})`;
-      const result = await this.executeQuery({ sql, params: [] });
-      if (!result || !Array.isArray(result)) {
-        return [];
-      }
-      return result.map((row) => ({
-        name: row.name,
-        type: row.type
-      }));
-    } catch (error) {
-      this.logger.error(`Error getting table columns for ${tableName}:`, {
-        message: error instanceof Error ? error.message : String(error)
-      });
-      return [];
+      return JSON.parse(value);
+    } catch {
+      return value;
     }
   }
-  // Helper to serialize objects to JSON strings
-  serializeValue(value) {
-    if (value === null || value === void 0) return null;
-    if (value instanceof Date) {
-      return this.serializeDate(value);
-    }
-    if (typeof value === "object") {
-      return JSON.stringify(value);
-    }
-    return value;
+  return value;
+}
+
+// src/storage/domains/legacy-evals/index.ts
+var LegacyEvalsStorageD1 = class extends storage.LegacyEvalsStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
   }
-  // Helper to deserialize JSON strings to objects
-  deserializeValue(value, type) {
-    if (value === null || value === void 0) return null;
-    if (type === "date" && typeof value === "string") {
-      return new Date(value);
+  async getEvals(options) {
+    const { agentName, type, page = 0, perPage = 40, dateRange } = options || {};
+    const fullTableName = this.operations.getTableName(storage.TABLE_EVALS);
+    const conditions = [];
+    const queryParams = [];
+    if (agentName) {
+      conditions.push(`agent_name = ?`);
+      queryParams.push(agentName);
     }
-    if (type === "jsonb" && typeof value === "string") {
-      try {
-        return JSON.parse(value);
-      } catch {
-        return value;
-      }
+    if (type === "test") {
+      conditions.push(`(test_info IS NOT NULL AND json_extract(test_info, '$.testPath') IS NOT NULL)`);
+    } else if (type === "live") {
+      conditions.push(`(test_info IS NULL OR json_extract(test_info, '$.testPath') IS NULL)`);
     }
-    if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
-      try {
-        return JSON.parse(value);
-      } catch {
-        return value;
-      }
+    if (dateRange?.start) {
+      conditions.push(`created_at >= ?`);
+      queryParams.push(storage.serializeDate(dateRange.start));
     }
-    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);
+    if (dateRange?.end) {
+      conditions.push(`created_at <= ?`);
+      queryParams.push(storage.serializeDate(dateRange.end));
     }
-  }
-  async createTable({
-    tableName,
-    schema
-  }) {
-    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 === storage.TABLE_WORKFLOW_SNAPSHOT) {
-      tableConstraints.push("UNIQUE (workflow_name, run_id)");
+    const countQueryBuilder = createSqlBuilder().count().from(fullTableName);
+    if (conditions.length > 0) {
+      countQueryBuilder.where(conditions.join(" AND "), ...queryParams);
     }
+    const { sql: countSql, params: countParams } = countQueryBuilder.build();
     try {
-      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$1) {
-      this.logger.error(`Error creating table ${fullTableName}:`, {
-        message: error$1 instanceof Error ? error$1.message : String(error$1)
+      const countResult = await this.operations.executeQuery({
+        sql: countSql,
+        params: countParams,
+        first: true
+      });
+      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);
+      }
+      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
+      };
+    } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_CREATE_TABLE_ERROR",
+          id: "CLOUDFLARE_D1_STORAGE_GET_EVALS_ERROR",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to create table ${fullTableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { tableName }
+          text: `Failed to retrieve evals for agent ${agentName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { agentName: agentName ?? "", type: type ?? "" }
         },
         error$1
       );
     }
   }
   /**
-   * 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
+   * @deprecated use getEvals instead
    */
-  async alterTable({
-    tableName,
-    schema,
-    ifNotExists
-  }) {
-    const fullTableName = this.getTableName(tableName);
+  async getEvalsByAgentName(agentName, type) {
+    const fullTableName = this.operations.getTableName(storage.TABLE_EVALS);
     try {
-      const existingColumns = await this.getTableColumns(fullTableName);
-      const existingColumnNames = new Set(existingColumns.map((col) => col.name.toLowerCase()));
-      for (const columnName of ifNotExists) {
-        if (!existingColumnNames.has(columnName.toLowerCase()) && schema[columnName]) {
-          const columnDef = schema[columnName];
-          const sqlType = this.getSqlType(columnDef.type);
-          const nullable = columnDef.nullable === false ? "NOT NULL" : "";
-          const defaultValue = columnDef.nullable === false ? this.getDefaultValue(columnDef.type) : "";
-          const alterSql = `ALTER TABLE ${fullTableName} ADD COLUMN ${columnName} ${sqlType} ${nullable} ${defaultValue}`.trim();
-          await this.executeQuery({ sql: alterSql, params: [] });
-          this.logger.debug(`Added column ${columnName} to table ${fullTableName}`);
-        }
+      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)");
       }
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "CLOUDFLARE_D1_STORAGE_ALTER_TABLE_ERROR",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to alter table ${fullTableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { tableName }
-        },
-        error$1
-      );
-    }
-  }
-  async clearTable({ tableName }) {
-    const fullTableName = this.getTableName(tableName);
-    try {
-      const query = createSqlBuilder().delete(fullTableName);
+      query.orderBy("created_at", "DESC");
       const { sql, params } = query.build();
-      await this.executeQuery({ sql, params });
-      this.logger.debug(`Cleared table ${fullTableName}`);
+      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
+        };
+      }) : [];
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_CLEAR_TABLE_ERROR",
+          id: "CLOUDFLARE_D1_STORAGE_GET_EVALS_ERROR",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to clear table ${fullTableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { tableName }
+          text: `Failed to retrieve evals for agent ${agentName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { agentName }
         },
         error$1
       );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return [];
     }
   }
-  async processRecord(record) {
-    const processedRecord = {};
-    for (const [key, value] of Object.entries(record)) {
-      processedRecord[key] = this.serializeValue(value);
+};
+var MemoryStorageD1 = class extends storage.MemoryStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
+  }
+  async getResourceById({ resourceId }) {
+    const resource = await this.operations.load({
+      tableName: storage.TABLE_RESOURCES,
+      keys: { id: resourceId }
+    });
+    if (!resource) return null;
+    try {
+      return {
+        ...resource,
+        createdAt: storage.ensureDate(resource.createdAt),
+        updatedAt: storage.ensureDate(resource.updatedAt),
+        metadata: typeof resource.metadata === "string" ? JSON.parse(resource.metadata || "{}") : resource.metadata
+      };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_RESOURCE_BY_ID_ERROR",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Error processing resource ${resourceId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { resourceId }
+        },
+        error$1
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return null;
     }
-    return processedRecord;
   }
-  async insert({ tableName, record }) {
-    const fullTableName = this.getTableName(tableName);
-    const processedRecord = await this.processRecord(record);
+  async saveResource({ resource }) {
+    const fullTableName = this.operations.getTableName(storage.TABLE_RESOURCES);
+    const resourceToSave = {
+      id: resource.id,
+      workingMemory: resource.workingMemory,
+      metadata: resource.metadata ? JSON.stringify(resource.metadata) : null,
+      createdAt: resource.createdAt,
+      updatedAt: resource.updatedAt
+    };
+    const processedRecord = await this.operations.processRecord(resourceToSave);
     const columns = Object.keys(processedRecord);
     const values = Object.values(processedRecord);
-    const query = createSqlBuilder().insert(fullTableName, columns, values);
+    const updateMap = {
+      workingMemory: "excluded.workingMemory",
+      metadata: "excluded.metadata",
+      createdAt: "excluded.createdAt",
+      updatedAt: "excluded.updatedAt"
+    };
+    const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], updateMap);
     const { sql, params } = query.build();
     try {
-      await this.executeQuery({ sql, params });
+      await this.operations.executeQuery({ sql, params });
+      return resource;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_INSERT_ERROR",
+          id: "CLOUDFLARE_D1_STORAGE_SAVE_RESOURCE_ERROR",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to insert into ${fullTableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { tableName }
+          text: `Failed to save resource to ${fullTableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { resourceId: resource.id }
         },
         error$1
       );
     }
   }
-  async load({ tableName, keys }) {
-    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);
-      }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    const existingResource = await this.getResourceById({ resourceId });
+    if (!existingResource) {
+      const newResource = {
+        id: resourceId,
+        workingMemory,
+        metadata: metadata || {},
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      return this.saveResource({ resource: newResource });
     }
-    query.limit(1);
+    const updatedAt = /* @__PURE__ */ new Date();
+    const updatedResource = {
+      ...existingResource,
+      workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+      metadata: {
+        ...existingResource.metadata,
+        ...metadata
+      },
+      updatedAt
+    };
+    const fullTableName = this.operations.getTableName(storage.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 {
-      const result = await this.executeQuery({ sql, params, first: true });
-      if (!result) return null;
-      const processedResult = {};
-      for (const [key, value] of Object.entries(result)) {
-        processedResult[key] = this.deserializeValue(value);
-      }
-      return processedResult;
+      await this.operations.executeQuery({ sql, params });
+      return updatedResource;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_LOAD_ERROR",
+          id: "CLOUDFLARE_D1_STORAGE_UPDATE_RESOURCE_ERROR",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to load from ${fullTableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { tableName }
+          text: `Failed to update resource ${resourceId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { resourceId }
         },
         error$1
       );
     }
   }
   async getThreadById({ threadId }) {
-    const thread = await this.load({
+    const thread = await this.operations.load({
       tableName: storage.TABLE_THREADS,
       keys: { id: threadId }
     });
@@ -634,8 +544,8 @@ var D1Store = class extends storage.MastraStorage {
     try {
       return {
         ...thread,
-        createdAt: this.ensureDate(thread.createdAt),
-        updatedAt: this.ensureDate(thread.updatedAt),
+        createdAt: storage.ensureDate(thread.createdAt),
+        updatedAt: storage.ensureDate(thread.updatedAt),
         metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata || "{}") : thread.metadata || {}
       };
     } catch (error$1) {
@@ -658,15 +568,15 @@ var D1Store = class extends storage.MastraStorage {
    * @deprecated use getThreadsByResourceIdPaginated instead
    */
   async getThreadsByResourceId({ resourceId }) {
-    const fullTableName = this.getTableName(storage.TABLE_THREADS);
+    const fullTableName = this.operations.getTableName(storage.TABLE_THREADS);
     try {
       const query = createSqlBuilder().select("*").from(fullTableName).where("resourceId = ?", resourceId);
       const { sql, params } = query.build();
-      const results = await this.executeQuery({ sql, params });
+      const results = await this.operations.executeQuery({ sql, params });
       return (isArrayOfRecords(results) ? results : []).map((thread) => ({
         ...thread,
-        createdAt: this.ensureDate(thread.createdAt),
-        updatedAt: this.ensureDate(thread.updatedAt),
+        createdAt: storage.ensureDate(thread.createdAt),
+        updatedAt: storage.ensureDate(thread.updatedAt),
         metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata || "{}") : thread.metadata || {}
       }));
     } catch (error$1) {
@@ -687,19 +597,19 @@ var D1Store = class extends storage.MastraStorage {
   }
   async getThreadsByResourceIdPaginated(args) {
     const { resourceId, page, perPage } = args;
-    const fullTableName = this.getTableName(storage.TABLE_THREADS);
+    const fullTableName = this.operations.getTableName(storage.TABLE_THREADS);
     const mapRowToStorageThreadType = (row) => ({
       ...row,
-      createdAt: this.ensureDate(row.createdAt),
-      updatedAt: this.ensureDate(row.updatedAt),
+      createdAt: storage.ensureDate(row.createdAt),
+      updatedAt: storage.ensureDate(row.updatedAt),
       metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata || "{}") : row.metadata || {}
     });
     try {
       const countQuery = createSqlBuilder().count().from(fullTableName).where("resourceId = ?", resourceId);
-      const countResult = await this.executeQuery(countQuery.build());
+      const countResult = await this.operations.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.executeQuery(selectQuery.build());
+      const results = await this.operations.executeQuery(selectQuery.build());
       const threads = results.map(mapRowToStorageThreadType);
       return {
         threads,
@@ -731,16 +641,16 @@ var D1Store = class extends storage.MastraStorage {
     }
   }
   async saveThread({ thread }) {
-    const fullTableName = this.getTableName(storage.TABLE_THREADS);
+    const fullTableName = this.operations.getTableName(storage.TABLE_THREADS);
     const threadToSave = {
       id: thread.id,
       resourceId: thread.resourceId,
       title: thread.title,
       metadata: thread.metadata ? JSON.stringify(thread.metadata) : null,
-      createdAt: thread.createdAt,
-      updatedAt: thread.updatedAt
+      createdAt: thread.createdAt.toISOString(),
+      updatedAt: thread.updatedAt.toISOString()
     };
-    const processedRecord = await this.processRecord(threadToSave);
+    const processedRecord = await this.operations.processRecord(threadToSave);
     const columns = Object.keys(processedRecord);
     const values = Object.values(processedRecord);
     const updateMap = {
@@ -753,7 +663,7 @@ var D1Store = class extends storage.MastraStorage {
     const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], updateMap);
     const { sql, params } = query.build();
     try {
-      await this.executeQuery({ sql, params });
+      await this.operations.executeQuery({ sql, params });
       return thread;
     } catch (error$1) {
       throw new error.MastraError(
@@ -778,16 +688,17 @@ var D1Store = class extends storage.MastraStorage {
       if (!thread) {
         throw new Error(`Thread ${id} not found`);
       }
-      const fullTableName = this.getTableName(storage.TABLE_THREADS);
+      const fullTableName = this.operations.getTableName(storage.TABLE_THREADS);
       const mergedMetadata = {
         ...typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
         ...metadata
       };
+      const updatedAt = /* @__PURE__ */ new Date();
       const columns = ["title", "metadata", "updatedAt"];
-      const values = [title, JSON.stringify(mergedMetadata), (/* @__PURE__ */ new Date()).toISOString()];
+      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.executeQuery({ sql, params });
+      await this.operations.executeQuery({ sql, params });
       return {
         ...thread,
         title,
@@ -795,7 +706,7 @@ var D1Store = class extends storage.MastraStorage {
           ...typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
           ...metadata
         },
-        updatedAt: /* @__PURE__ */ new Date()
+        updatedAt
       };
     } catch (error$1) {
       throw new error.MastraError(
@@ -811,15 +722,15 @@ var D1Store = class extends storage.MastraStorage {
     }
   }
   async deleteThread({ threadId }) {
-    const fullTableName = this.getTableName(storage.TABLE_THREADS);
+    const fullTableName = this.operations.getTableName(storage.TABLE_THREADS);
     try {
       const deleteThreadQuery = createSqlBuilder().delete(fullTableName).where("id = ?", threadId);
       const { sql: threadSql, params: threadParams } = deleteThreadQuery.build();
-      await this.executeQuery({ sql: threadSql, params: threadParams });
-      const messagesTableName = this.getTableName(storage.TABLE_MESSAGES);
+      await this.operations.executeQuery({ sql: threadSql, params: threadParams });
+      const messagesTableName = this.operations.getTableName(storage.TABLE_MESSAGES);
       const deleteMessagesQuery = createSqlBuilder().delete(messagesTableName).where("thread_id = ?", threadId);
       const { sql: messagesSql, params: messagesParams } = deleteMessagesQuery.build();
-      await this.executeQuery({ sql: messagesSql, params: messagesParams });
+      await this.operations.executeQuery({ sql: messagesSql, params: messagesParams });
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -841,9 +752,18 @@ var D1Store = class extends storage.MastraStorage {
       const threadId = messages[0]?.threadId;
       for (const [i, message] of messages.entries()) {
         if (!message.id) throw new Error(`Message at index ${i} missing id`);
-        if (!message.threadId) throw new Error(`Message at index ${i} missing threadId`);
-        if (!message.content) throw new Error(`Message at index ${i} missing content`);
-        if (!message.role) throw new Error(`Message at index ${i} missing role`);
+        if (!message.threadId) {
+          throw new Error(`Message at index ${i} missing threadId`);
+        }
+        if (!message.content) {
+          throw new Error(`Message at index ${i} missing content`);
+        }
+        if (!message.role) {
+          throw new Error(`Message at index ${i} missing role`);
+        }
+        if (!message.resourceId) {
+          throw new Error(`Message at index ${i} missing resourceId`);
+        }
         const thread = await this.getThreadById({ threadId: message.threadId });
         if (!thread) {
           throw new Error(`Thread ${message.threadId} not found`);
@@ -862,13 +782,13 @@ var D1Store = class extends storage.MastraStorage {
         };
       });
       await Promise.all([
-        this.batchUpsert({
+        this.operations.batchUpsert({
           tableName: storage.TABLE_MESSAGES,
           records: messagesToInsert
         }),
         // Update thread's updatedAt timestamp
-        this.executeQuery({
-          sql: `UPDATE ${this.getTableName(storage.TABLE_THREADS)} SET updatedAt = ? WHERE id = ?`,
+        this.operations.executeQuery({
+          sql: `UPDATE ${this.operations.getTableName(storage.TABLE_THREADS)} SET updatedAt = ? WHERE id = ?`,
           params: [now.toISOString(), threadId]
         })
       ]);
@@ -889,61 +809,78 @@ var D1Store = class extends storage.MastraStorage {
     }
   }
   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;
-    const prevMax = Math.max(...include.map((i) => i.withPreviousMessages || 0));
-    const nextMax = Math.max(...include.map((i) => i.withNextMessages || 0));
-    const includeIds = include.map((i) => i.id);
-    const sql = `
-        WITH ordered_messages AS (
-          SELECT
-            *,
-            ROW_NUMBER() OVER (ORDER BY createdAt DESC) AS row_num
-          FROM ${this.getTableName(storage.TABLE_MESSAGES)}
-          WHERE thread_id = ?
-        )
-        SELECT
-          m.id,
-          m.content,
-          m.role,
-          m.type,
-          m.createdAt,
-          m.thread_id AS threadId
-        FROM ordered_messages m
-        WHERE m.id IN (${includeIds.map(() => "?").join(",")})
-        OR EXISTS (
-          SELECT 1 FROM ordered_messages target
-          WHERE target.id IN (${includeIds.map(() => "?").join(",")})
-          AND (
-            (m.row_num <= target.row_num + ? AND m.row_num > target.row_num)
-            OR
-            (m.row_num >= target.row_num - ? AND m.row_num < target.row_num)
-          )
-        )
-        ORDER BY m.createdAt DESC
-      `;
-    const params = [
-      threadId,
-      ...includeIds,
-      // for m.id IN (...)
-      ...includeIds,
-      // for target.id IN (...)
-      prevMax,
-      nextMax
-    ];
-    const messages = await this.executeQuery({ sql, params });
-    return messages;
+    const unionQueries = [];
+    const params = [];
+    let paramIdx = 1;
+    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 (
+                    SELECT
+                      *,
+                      ROW_NUMBER() OVER (ORDER BY createdAt ASC) AS row_num
+                    FROM ${this.operations.getTableName(storage.TABLE_MESSAGES)}
+                    WHERE thread_id = ?
+                  )
+                  SELECT
+                    m.id,
+                    m.content,
+                    m.role,
+                    m.type,
+                    m.createdAt,
+                    m.thread_id AS threadId,
+                    m.resourceId
+                  FROM ordered_messages m
+                  WHERE m.id = ?
+                  OR EXISTS (
+                    SELECT 1 FROM ordered_messages target
+                    WHERE target.id = ?
+                    AND (
+                      (m.row_num <= target.row_num + ? AND m.row_num > target.row_num)
+                      OR
+                      (m.row_num >= target.row_num - ? AND m.row_num < target.row_num)
+                    )
+                  )
+                ) AS query_${paramIdx}
+            `);
+      params.push(searchId, id, id, withNextMessages, withPreviousMessages);
+      paramIdx++;
+    }
+    const finalQuery = unionQueries.join(" UNION ALL ") + " ORDER BY createdAt ASC";
+    const messages = await this.operations.executeQuery({ sql: finalQuery, params });
+    if (!Array.isArray(messages)) {
+      return [];
+    }
+    const processedMessages = messages.map((message) => {
+      const processedMsg = {};
+      for (const [key, value] of Object.entries(message)) {
+        if (key === `type` && value === `v2`) continue;
+        processedMsg[key] = deserializeValue(value);
+      }
+      return processedMsg;
+    });
+    return processedMessages;
   }
   async getMessages({
     threadId,
+    resourceId,
     selectBy,
     format
   }) {
-    const fullTableName = this.getTableName(storage.TABLE_MESSAGES);
-    const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
-    const include = selectBy?.include || [];
-    const messages = [];
     try {
+      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
+      const fullTableName = this.operations.getTableName(storage.TABLE_MESSAGES);
+      const limit = storage.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);
@@ -955,7 +892,7 @@ var D1Store = class extends storage.MastraStorage {
       }
       query.orderBy("createdAt", "DESC").limit(limit);
       const { sql, params } = query.build();
-      const result = await this.executeQuery({ sql, params });
+      const result = await this.operations.executeQuery({ sql, params });
       if (Array.isArray(result)) messages.push(...result);
       messages.sort((a, b) => {
         const aRecord = a;
@@ -968,7 +905,7 @@ var D1Store = class extends storage.MastraStorage {
         const processedMsg = {};
         for (const [key, value] of Object.entries(message)) {
           if (key === `type` && value === `v2`) continue;
-          processedMsg[key] = this.deserializeValue(value);
+          processedMsg[key] = deserializeValue(value);
         }
         return processedMsg;
       });
@@ -983,7 +920,48 @@ var D1Store = class extends storage.MastraStorage {
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Failed to retrieve messages for thread ${threadId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { threadId }
+          details: { threadId, resourceId: resourceId ?? "" }
+        },
+        error$1
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      throw mastraError;
+    }
+  }
+  async getMessagesById({
+    messageIds,
+    format
+  }) {
+    if (messageIds.length === 0) return [];
+    const fullTableName = this.operations.getTableName(storage.TABLE_MESSAGES);
+    const messages = [];
+    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 processedMsg = {};
+        for (const [key, value] of Object.entries(message)) {
+          if (key === `type` && value === `v2`) continue;
+          processedMsg[key] = deserializeValue(value);
+        }
+        return processedMsg;
+      });
+      this.logger.debug(`Retrieved ${messages.length} messages`);
+      const list = new agent.MessageList().add(processedMessages, "memory");
+      if (format === `v1`) return list.get.all.v1();
+      return list.get.all.v2();
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_MESSAGES_BY_ID_ERROR",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Failed to retrieve messages by ID: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { messageIds: JSON.stringify(messageIds) }
         },
         error$1
       );
@@ -994,44 +972,97 @@ var D1Store = class extends storage.MastraStorage {
   }
   async getMessagesPaginated({
     threadId,
+    resourceId,
     selectBy,
     format
   }) {
-    const { dateRange, page = 0, perPage = 40 } = selectBy?.pagination || {};
+    const { dateRange, page = 0, perPage: perPageInput } = selectBy?.pagination || {};
     const { start: fromDate, end: toDate } = dateRange || {};
-    const fullTableName = this.getTableName(storage.TABLE_MESSAGES);
+    const perPage = perPageInput !== void 0 ? perPageInput : storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
+    const fullTableName = this.operations.getTableName(storage.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 countQuery = createSqlBuilder().count().from(fullTableName).where("thread_id = ?", threadId);
       if (fromDate) {
-        countQuery.andWhere("createdAt >= ?", this.serializeDate(fromDate));
+        countQuery.andWhere("createdAt >= ?", storage.serializeDate(fromDate));
       }
       if (toDate) {
-        countQuery.andWhere("createdAt <= ?", this.serializeDate(toDate));
+        countQuery.andWhere("createdAt <= ?", storage.serializeDate(toDate));
       }
-      const countResult = await this.executeQuery(countQuery.build());
+      const countResult = await this.operations.executeQuery(countQuery.build());
       const total = Number(countResult[0]?.count ?? 0);
-      const query = createSqlBuilder().select(["id", "content", "role", "type", "createdAt", "thread_id AS threadId"]).from(fullTableName).where("thread_id = ?", threadId);
+      if (total === 0 && messages.length === 0) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage,
+          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) {
-        query.andWhere("createdAt >= ?", this.serializeDate(fromDate));
+        queryParams.push(storage.serializeDate(fromDate));
       }
       if (toDate) {
-        query.andWhere("createdAt <= ?", this.serializeDate(toDate));
+        queryParams.push(storage.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 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);
+        }
+        return processedMsg;
+      });
+      if (selectBy?.last) {
+        processedMessages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
       }
-      query.orderBy("createdAt", "DESC").limit(perPage).offset(page * perPage);
-      const results = await this.executeQuery(query.build());
-      const list = new agent.MessageList().add(results, "memory");
+      const list = new agent.MessageList().add(processedMessages, "memory");
       messages.push(...format === `v2` ? list.get.all.v2() : list.get.all.v1());
       return {
         messages,
         total,
         page,
         perPage,
-        hasMore: page * perPage + messages.length < total
+        hasMore: selectBy?.last ? false : page * perPage + messages.length < total
       };
     } catch (error$1) {
       const mastraError = new error.MastraError(
@@ -1040,7 +1071,7 @@ var D1Store = class extends storage.MastraStorage {
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Failed to retrieve messages for thread ${threadId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { threadId }
+          details: { threadId, resourceId: resourceId ?? "" }
         },
         error$1
       );
@@ -1055,132 +1086,446 @@ var D1Store = class extends storage.MastraStorage {
       };
     }
   }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    snapshot
-  }) {
-    const fullTableName = this.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const currentSnapshot = await this.load({
-      tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
-      keys: { workflow_name: workflowName, run_id: runId }
-    });
-    const persisting = currentSnapshot ? {
-      ...currentSnapshot,
-      snapshot: JSON.stringify(snapshot),
-      updatedAt: now
-    } : {
-      workflow_name: workflowName,
-      run_id: runId,
-      snapshot,
-      createdAt: now,
-      updatedAt: now
-    };
-    const processedRecord = await this.processRecord(persisting);
-    const columns = Object.keys(processedRecord);
-    const values = Object.values(processedRecord);
-    const updateMap = {
-      snapshot: "excluded.snapshot",
-      updatedAt: "excluded.updatedAt"
-    };
-    this.logger.debug("Persisting workflow snapshot", { workflowName, runId });
-    const query = createSqlBuilder().insert(fullTableName, columns, values, ["workflow_name", "run_id"], updateMap);
-    const { sql, params } = query.build();
+  async updateMessages(args) {
+    const { messages } = args;
+    this.logger.debug("Updating messages", { count: messages.length });
+    if (!messages.length) {
+      return [];
+    }
+    const messageIds = messages.map((m) => m.id);
+    const fullTableName = this.operations.getTableName(storage.TABLE_MESSAGES);
+    const threadsTableName = this.operations.getTableName(storage.TABLE_THREADS);
     try {
-      await this.executeQuery({ sql, params });
+      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 });
+      if (existingMessages.length === 0) {
+        return [];
+      }
+      const parsedExistingMessages = existingMessages.map((msg) => {
+        if (typeof msg.content === "string") {
+          try {
+            msg.content = JSON.parse(msg.content);
+          } catch {
+          }
+        }
+        return msg;
+      });
+      const threadIdsToUpdate = /* @__PURE__ */ new Set();
+      const updateQueries = [];
+      for (const existingMessage of parsedExistingMessages) {
+        const updatePayload = messages.find((m) => m.id === existingMessage.id);
+        if (!updatePayload) continue;
+        const { id, ...fieldsToUpdate } = updatePayload;
+        if (Object.keys(fieldsToUpdate).length === 0) continue;
+        threadIdsToUpdate.add(existingMessage.threadId);
+        if ("threadId" in updatePayload && updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+          threadIdsToUpdate.add(updatePayload.threadId);
+        }
+        const setClauses = [];
+        const values = [];
+        const updatableFields = { ...fieldsToUpdate };
+        if (updatableFields.content) {
+          const existingContent = existingMessage.content || {};
+          const newContent = {
+            ...existingContent,
+            ...updatableFields.content,
+            // Deep merge metadata if it exists on both
+            ...existingContent?.metadata && updatableFields.content.metadata ? {
+              metadata: {
+                ...existingContent.metadata,
+                ...updatableFields.content.metadata
+              }
+            } : {}
+          };
+          setClauses.push(`content = ?`);
+          values.push(JSON.stringify(newContent));
+          delete updatableFields.content;
+        }
+        for (const key in updatableFields) {
+          if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+            const dbColumn = key === "threadId" ? "thread_id" : key;
+            setClauses.push(`${dbColumn} = ?`);
+            values.push(updatableFields[key]);
+          }
+        }
+        if (setClauses.length > 0) {
+          values.push(id);
+          const updateQuery = `UPDATE ${fullTableName} SET ${setClauses.join(", ")} WHERE id = ?`;
+          updateQueries.push({ sql: updateQuery, params: values });
+        }
+      }
+      for (const query of updateQueries) {
+        await this.operations.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 });
+      }
+      const updatedMessages = await this.operations.executeQuery({ sql: selectQuery, params: messageIds });
+      return updatedMessages.map((message) => {
+        if (typeof message.content === "string") {
+          try {
+            message.content = JSON.parse(message.content);
+          } catch {
+          }
+        }
+        return message;
+      });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_PERSIST_WORKFLOW_SNAPSHOT_ERROR",
+          id: "CLOUDFLARE_D1_STORAGE_UPDATE_MESSAGES_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to persist workflow snapshot: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { workflowName, runId }
+          details: { count: messages.length }
         },
         error$1
       );
     }
   }
-  async loadWorkflowSnapshot(params) {
-    const { workflowName, runId } = params;
-    this.logger.debug("Loading workflow snapshot", { workflowName, runId });
+};
+var StoreOperationsD1 = class extends storage.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 d = await this.load({
-        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
-        keys: {
-          workflow_name: workflowName,
-          run_id: runId
+      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;
         }
-      });
-      return d ? d.snapshot : null;
+      } 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$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_LOAD_WORKFLOW_SNAPSHOT_ERROR",
+          id: "CLOUDFLARE_D1_STORE_OPERATIONS_WORKERS_BINDING_QUERY_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to load workflow snapshot: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { workflowName, runId }
+          details: { sql }
         },
         error$1
       );
     }
   }
-  /**
-   * Insert multiple records in a batch operation
-   * @param tableName The table to insert into
-   * @param records The records to insert
-   */
-  async batchInsert({ tableName, records }) {
-    if (records.length === 0) return;
-    const fullTableName = this.getTableName(tableName);
+  async executeRestQuery({
+    sql,
+    params = [],
+    first = false
+  }) {
+    if (!this.client) {
+      throw new Error("D1 client is not configured");
+    }
     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 query = createSqlBuilder().insert(fullTableName, columns, values);
-            const { sql, params } = query.build();
-            await this.executeQuery({ sql, params });
-          }
+      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$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORE_OPERATIONS_REST_QUERY_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { sql }
+        },
+        error$1
+      );
+    }
+  }
+  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 === storage.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$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORE_OPERATIONS_CREATE_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  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$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORE_OPERATIONS_CLEAR_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  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$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORE_OPERATIONS_DROP_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  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}`);
         }
-        this.logger.debug(
-          `Processed batch ${Math.floor(i / batchSize) + 1} of ${Math.ceil(records.length / batchSize)}`
-        );
       }
-      this.logger.debug(`Successfully batch inserted ${records.length} records into ${tableName}`);
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_BATCH_INSERT_ERROR",
+          id: "CLOUDFLARE_D1_STORE_OPERATIONS_ALTER_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName: args.tableName }
+        },
+        error$1
+      );
+    }
+  }
+  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$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORE_OPERATIONS_INSERT_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to batch insert into ${tableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
           details: { tableName }
         },
         error$1
       );
     }
   }
+  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$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORE_OPERATIONS_BATCH_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  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$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORE_OPERATIONS_LOAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  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
-  }) {
+  async batchUpsert({ tableName, records }) {
     if (records.length === 0) return;
     const fullTableName = this.getTableName(tableName);
     try {
@@ -1227,73 +1572,349 @@ var D1Store = class extends storage.MastraStorage {
       );
     }
   }
-  /**
-   * @deprecated use getTracesPaginated instead
-   */
-  async getTraces({
-    name,
-    scope,
-    page,
-    perPage,
-    attributes,
-    fromDate,
-    toDate
+};
+function transformScoreRow(row) {
+  const deserialized = { ...row };
+  deserialized.input = storage.safelyParseJSON(row.input);
+  deserialized.output = storage.safelyParseJSON(row.output);
+  deserialized.scorer = storage.safelyParseJSON(row.scorer);
+  deserialized.preprocessStepResult = storage.safelyParseJSON(row.preprocessStepResult);
+  deserialized.analyzeStepResult = storage.safelyParseJSON(row.analyzeStepResult);
+  deserialized.metadata = storage.safelyParseJSON(row.metadata);
+  deserialized.additionalContext = storage.safelyParseJSON(row.additionalContext);
+  deserialized.runtimeContext = storage.safelyParseJSON(row.runtimeContext);
+  deserialized.entity = storage.safelyParseJSON(row.entity);
+  deserialized.createdAt = row.createdAtZ || row.createdAt;
+  deserialized.updatedAt = row.updatedAtZ || row.updatedAt;
+  return deserialized;
+}
+var ScoresStorageD1 = class extends storage.ScoresStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
+  }
+  async getScoreById({ id }) {
+    try {
+      const fullTableName = this.operations.getTableName(storage.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 });
+      if (!result) {
+        return null;
+      }
+      return transformScoreRow(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORE_SCORES_GET_SCORE_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async saveScore(score) {
+    let parsedScore;
+    try {
+      parsedScore = scores.saveScorePayloadSchema.parse(score);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORE_SCORES_SAVE_SCORE_FAILED_INVALID_SCORE_PAYLOAD",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { scoreId: score.id }
+        },
+        error$1
+      );
+    }
+    try {
+      const id = crypto.randomUUID();
+      const fullTableName = this.operations.getTableName(storage.TABLE_SCORERS);
+      const serializedRecord = {};
+      for (const [key, value] of Object.entries(parsedScore)) {
+        if (value !== null && value !== void 0) {
+          if (typeof value === "object") {
+            serializedRecord[key] = JSON.stringify(value);
+          } else {
+            serializedRecord[key] = value;
+          }
+        } else {
+          serializedRecord[key] = null;
+        }
+      }
+      serializedRecord.id = id;
+      serializedRecord.createdAt = (/* @__PURE__ */ new Date()).toISOString();
+      serializedRecord.updatedAt = (/* @__PURE__ */ new Date()).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 };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORE_SCORES_SAVE_SCORE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getScoresByScorerId({
+    scorerId,
+    entityId,
+    entityType,
+    source,
+    pagination
   }) {
-    const fullTableName = this.getTableName(storage.TABLE_TRACES);
     try {
-      const query = createSqlBuilder().select("*").from(fullTableName).where("1=1");
-      if (name) {
-        query.andWhere("name LIKE ?", `%${name}%`);
+      const fullTableName = this.operations.getTableName(storage.TABLE_SCORERS);
+      const countQuery = createSqlBuilder().count().from(fullTableName).where("scorerId = ?", scorerId);
+      if (entityId) {
+        countQuery.andWhere("entityId = ?", entityId);
       }
-      if (scope) {
-        query.andWhere("scope = ?", scope);
+      if (entityType) {
+        countQuery.andWhere("entityType = ?", entityType);
       }
-      if (attributes && Object.keys(attributes).length > 0) {
-        for (const [key, value] of Object.entries(attributes)) {
-          query.jsonLike("attributes", key, value);
-        }
+      if (source) {
+        countQuery.andWhere("source = ?", source);
       }
-      if (fromDate) {
-        query.andWhere("createdAt >= ?", fromDate instanceof Date ? fromDate.toISOString() : fromDate);
+      const countResult = await this.operations.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,
+            hasMore: false
+          },
+          scores: []
+        };
       }
-      if (toDate) {
-        query.andWhere("createdAt <= ?", toDate instanceof Date ? toDate.toISOString() : toDate);
+      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("scorerId = ?", scorerId);
+      if (entityId) {
+        selectQuery.andWhere("entityId = ?", entityId);
       }
-      query.orderBy("startTime", "DESC").limit(perPage).offset(page * perPage);
-      const { sql, params } = query.build();
-      const results = await this.executeQuery({ sql, params });
-      return isArrayOfRecords(results) ? results.map(
-        (trace) => ({
-          ...trace,
-          attributes: this.deserializeValue(trace.attributes, "jsonb"),
-          status: this.deserializeValue(trace.status, "jsonb"),
-          events: this.deserializeValue(trace.events, "jsonb"),
-          links: this.deserializeValue(trace.links, "jsonb"),
-          other: this.deserializeValue(trace.other, "jsonb")
-        })
-      ) : [];
+      if (entityType) {
+        selectQuery.andWhere("entityType = ?", entityType);
+      }
+      if (source) {
+        selectQuery.andWhere("source = ?", source);
+      }
+      selectQuery.limit(pagination.perPage).offset(pagination.page * pagination.perPage);
+      const { sql, params } = selectQuery.build();
+      const results = await this.operations.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
+        },
+        scores
+      };
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORE_SCORES_GET_SCORES_BY_SCORER_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getScoresByRunId({
+    runId,
+    pagination
+  }) {
+    try {
+      const fullTableName = this.operations.getTableName(storage.TABLE_SCORERS);
+      const countQuery = createSqlBuilder().count().from(fullTableName).where("runId = ?", runId);
+      const countResult = await this.operations.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,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("runId = ?", runId).limit(pagination.perPage).offset(pagination.page * pagination.perPage);
+      const { sql, params } = selectQuery.build();
+      const results = await this.operations.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
+        },
+        scores
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORE_SCORES_GET_SCORES_BY_RUN_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    try {
+      const fullTableName = this.operations.getTableName(storage.TABLE_SCORERS);
+      const countQuery = createSqlBuilder().count().from(fullTableName).where("entityId = ?", entityId).andWhere("entityType = ?", entityType);
+      const countResult = await this.operations.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,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("entityId = ?", entityId).andWhere("entityType = ?", entityType).limit(pagination.perPage).offset(pagination.page * pagination.perPage);
+      const { sql, params } = selectQuery.build();
+      const results = await this.operations.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
+        },
+        scores
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORE_SCORES_GET_SCORES_BY_ENTITY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getScoresBySpan({
+    traceId,
+    spanId,
+    pagination
+  }) {
+    try {
+      const fullTableName = this.operations.getTableName(storage.TABLE_SCORERS);
+      const countQuery = createSqlBuilder().count().from(fullTableName).where("traceId = ?", traceId).andWhere("spanId = ?", spanId);
+      const countResult = await this.operations.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,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const limit = pagination.perPage + 1;
+      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("traceId = ?", traceId).andWhere("spanId = ?", spanId).orderBy("createdAt", "DESC").limit(limit).offset(pagination.page * pagination.perPage);
+      const { sql, params } = selectQuery.build();
+      const results = await this.operations.executeQuery({ sql, params });
+      const rows = Array.isArray(results) ? results : [];
+      const scores = rows.slice(0, pagination.perPage).map(transformScoreRow);
+      return {
+        pagination: {
+          total,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: rows.length > pagination.perPage
+        },
+        scores
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORE_SCORES_GET_SCORES_BY_SPAN_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+};
+function isArrayOfRecords2(value) {
+  return value && Array.isArray(value) && value.length > 0;
+}
+var TracesStorageD1 = class extends storage.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$1) {
+      throw new error.MastraError(
         {
           id: "CLOUDFLARE_D1_STORAGE_GET_TRACES_ERROR",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Failed to retrieve traces: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
           details: {
-            name: name ?? "",
-            scope: scope ?? ""
+            name: args.name ?? "",
+            scope: args.scope ?? ""
           }
         },
         error$1
       );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return [];
     }
   }
   async getTracesPaginated(args) {
-    const { name, scope, page, perPage, attributes, fromDate, toDate } = args;
-    const fullTableName = this.getTableName(storage.TABLE_TRACES);
+    const { name, scope, page = 0, perPage = 100, attributes, dateRange } = args;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const fullTableName = this.operations.getTableName(storage.TABLE_TRACES);
     try {
       const dataQuery = createSqlBuilder().select("*").from(fullTableName).where("1=1");
       const countQuery = createSqlBuilder().count().from(fullTableName).where("1=1");
@@ -1321,18 +1942,22 @@ var D1Store = class extends storage.MastraStorage {
         dataQuery.andWhere("createdAt <= ?", toDateStr);
         countQuery.andWhere("createdAt <= ?", toDateStr);
       }
-      const countResult = await this.executeQuery(countQuery.build());
+      const allDataResult = await this.operations.executeQuery(
+        createSqlBuilder().select("*").from(fullTableName).where("1=1").build()
+      );
+      console.info("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.executeQuery(dataQuery.build());
-      const traces = isArrayOfRecords(results) ? results.map(
+      const results = await this.operations.executeQuery(dataQuery.build());
+      const traces = isArrayOfRecords2(results) ? results.map(
         (trace) => ({
           ...trace,
-          attributes: this.deserializeValue(trace.attributes, "jsonb"),
-          status: this.deserializeValue(trace.status, "jsonb"),
-          events: this.deserializeValue(trace.events, "jsonb"),
-          links: this.deserializeValue(trace.links, "jsonb"),
-          other: this.deserializeValue(trace.other, "jsonb")
+          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")
         })
       ) : [];
       return {
@@ -1345,7 +1970,7 @@ var D1Store = class extends storage.MastraStorage {
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_TRACES_ERROR",
+          id: "CLOUDFLARE_D1_STORAGE_GET_TRACES_PAGINATED_ERROR",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Failed to retrieve traces: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
@@ -1358,135 +1983,106 @@ var D1Store = class extends storage.MastraStorage {
       return { traces: [], total: 0, page, perPage, hasMore: false };
     }
   }
-  /**
-   * @deprecated use getEvals instead
-   */
-  async getEvalsByAgentName(agentName, type) {
-    const fullTableName = this.getTableName(storage.TABLE_EVALS);
+  async batchTraceInsert({ records }) {
+    this.logger.debug("Batch inserting traces", { count: records.length });
+    await this.operations.batchInsert({
+      tableName: storage.TABLE_TRACES,
+      records
+    });
+  }
+};
+var WorkflowsStorageD1 = class extends storage.WorkflowsStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
+  }
+  updateWorkflowResults({
+    // workflowName,
+    // runId,
+    // stepId,
+    // result,
+    // runtimeContext,
+  }) {
+    throw new Error("Method not implemented.");
+  }
+  updateWorkflowState({
+    // workflowName,
+    // runId,
+    // opts,
+  }) {
+    throw new Error("Method not implemented.");
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    resourceId,
+    snapshot
+  }) {
+    const fullTableName = this.operations.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const currentSnapshot = await this.operations.load({
+      tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+      keys: { workflow_name: workflowName, run_id: runId }
+    });
+    const persisting = currentSnapshot ? {
+      ...currentSnapshot,
+      resourceId,
+      snapshot: JSON.stringify(snapshot),
+      updatedAt: now
+    } : {
+      workflow_name: workflowName,
+      run_id: runId,
+      resourceId,
+      snapshot,
+      createdAt: now,
+      updatedAt: now
+    };
+    const processedRecord = await this.operations.processRecord(persisting);
+    const columns = Object.keys(processedRecord);
+    const values = Object.values(processedRecord);
+    const updateMap = {
+      snapshot: "excluded.snapshot",
+      updatedAt: "excluded.updatedAt"
+    };
+    this.logger.debug("Persisting workflow snapshot", { workflowName, runId });
+    const query = createSqlBuilder().insert(fullTableName, columns, values, ["workflow_name", "run_id"], updateMap);
+    const { sql, params } = query.build();
     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 { sql, params } = query.build();
-      const results = await this.executeQuery({ sql, params });
-      return isArrayOfRecords(results) ? results.map((row) => {
-        const result = this.deserializeValue(row.result);
-        const testInfo = row.test_info ? this.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.operations.executeQuery({ sql, params });
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_EVALS_ERROR",
+          id: "CLOUDFLARE_D1_STORAGE_PERSIST_WORKFLOW_SNAPSHOT_ERROR",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to retrieve evals for agent ${agentName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { agentName }
+          text: `Failed to persist workflow snapshot: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { workflowName, runId }
         },
-        error$1
-      );
-      this.logger?.error(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return [];
-    }
-  }
-  async getEvals(options) {
-    const { agentName, type, page = 0, perPage = 40, fromDate, toDate } = options || {};
-    const fullTableName = this.getTableName(storage.TABLE_EVALS);
-    const conditions = [];
-    const queryParams = [];
-    if (agentName) {
-      conditions.push(`agent_name = ?`);
-      queryParams.push(agentName);
-    }
-    if (type === "test") {
-      conditions.push(`(test_info IS NOT NULL AND json_extract(test_info, '$.testPath') IS NOT NULL)`);
-    } else if (type === "live") {
-      conditions.push(`(test_info IS NULL OR json_extract(test_info, '$.testPath') IS NULL)`);
-    }
-    if (fromDate) {
-      conditions.push(`createdAt >= ?`);
-      queryParams.push(this.serializeDate(fromDate));
-    }
-    if (toDate) {
-      conditions.push(`createdAt <= ?`);
-      queryParams.push(this.serializeDate(toDate));
-    }
-    const countQueryBuilder = createSqlBuilder().count().from(fullTableName);
-    if (conditions.length > 0) {
-      countQueryBuilder.where(conditions.join(" AND "), ...queryParams);
+        error$1
+      );
     }
-    const { sql: countSql, params: countParams } = countQueryBuilder.build();
+  }
+  async loadWorkflowSnapshot(params) {
+    const { workflowName, runId } = params;
+    this.logger.debug("Loading workflow snapshot", { workflowName, runId });
     try {
-      const countResult = await this.executeQuery({ sql: countSql, params: countParams, first: true });
-      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);
-      }
-      dataQueryBuilder.orderBy("createdAt", "DESC").limit(perPage).offset(currentOffset);
-      const { sql: dataSql, params: dataParams } = dataQueryBuilder.build();
-      const rows = await this.executeQuery({ sql: dataSql, params: dataParams });
-      const evals = (isArrayOfRecords(rows) ? rows : []).map((row) => {
-        const result = this.deserializeValue(row.result);
-        const testInfo = row.test_info ? this.deserializeValue(row.test_info) : void 0;
-        if (!result || typeof result !== "object" || !("score" in result)) {
-          throw new Error(`Invalid MetricResult format: ${JSON.stringify(result)}`);
+      const d = await this.operations.load({
+        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+        keys: {
+          workflow_name: workflowName,
+          run_id: runId
         }
-        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.createdAt
-        };
       });
-      const hasMore = currentOffset + evals.length < total;
-      return {
-        evals,
-        total,
-        page,
-        perPage,
-        hasMore
-      };
+      return d ? d.snapshot : null;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "CLOUDFLARE_D1_STORAGE_GET_EVALS_ERROR",
+          id: "CLOUDFLARE_D1_STORAGE_LOAD_WORKFLOW_SNAPSHOT_ERROR",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          text: `Failed to retrieve evals for agent ${agentName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { agentName: agentName ?? "", type: type ?? "" }
+          text: `Failed to load workflow snapshot: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { workflowName, runId }
         },
         error$1
       );
@@ -1505,17 +2101,11 @@ var D1Store = class extends storage.MastraStorage {
       workflowName: row.workflow_name,
       runId: row.run_id,
       snapshot: parsedSnapshot,
-      createdAt: this.ensureDate(row.createdAt),
-      updatedAt: this.ensureDate(row.updatedAt),
+      createdAt: storage.ensureDate(row.createdAt),
+      updatedAt: storage.ensureDate(row.updatedAt),
       resourceId: row.resourceId
     };
   }
-  async hasColumn(table, column) {
-    const sql = `PRAGMA table_info(${table});`;
-    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());
-  }
   async getWorkflowRuns({
     workflowName,
     fromDate,
@@ -1524,13 +2114,13 @@ var D1Store = class extends storage.MastraStorage {
     offset,
     resourceId
   } = {}) {
-    const fullTableName = this.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
+    const fullTableName = this.operations.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
     try {
       const builder = createSqlBuilder().select().from(fullTableName);
       const countBuilder = createSqlBuilder().count().from(fullTableName);
       if (workflowName) builder.whereAnd("workflow_name = ?", workflowName);
       if (resourceId) {
-        const hasResourceId = await this.hasColumn(fullTableName, "resourceId");
+        const hasResourceId = await this.operations.hasColumn(fullTableName, "resourceId");
         if (hasResourceId) {
           builder.whereAnd("resourceId = ?", resourceId);
           countBuilder.whereAnd("resourceId = ?", resourceId);
@@ -1553,10 +2143,14 @@ var D1Store = class extends storage.MastraStorage {
       let total = 0;
       if (limit !== void 0 && offset !== void 0) {
         const { sql: countSql, params: countParams } = countBuilder.build();
-        const countResult = await this.executeQuery({ sql: countSql, params: countParams, first: true });
+        const countResult = await this.operations.executeQuery({
+          sql: countSql,
+          params: countParams,
+          first: true
+        });
         total = Number(countResult?.count ?? 0);
       }
-      const results = await this.executeQuery({ sql, params });
+      const results = await this.operations.executeQuery({ sql, params });
       const runs = (isArrayOfRecords(results) ? results : []).map((row) => this.parseWorkflowRun(row));
       return { runs, total: total || runs.length };
     } catch (error$1) {
@@ -1566,7 +2160,10 @@ var D1Store = class extends storage.MastraStorage {
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           text: `Failed to retrieve workflow runs: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
-          details: { workflowName: workflowName ?? "", resourceId: resourceId ?? "" }
+          details: {
+            workflowName: workflowName ?? "",
+            resourceId: resourceId ?? ""
+          }
         },
         error$1
       );
@@ -1576,7 +2173,7 @@ var D1Store = class extends storage.MastraStorage {
     runId,
     workflowName
   }) {
-    const fullTableName = this.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
+    const fullTableName = this.operations.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
     try {
       const conditions = [];
       const params = [];
@@ -1590,7 +2187,7 @@ var D1Store = class extends storage.MastraStorage {
       }
       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.executeQuery({ sql, params, first: true });
+      const result = await this.operations.executeQuery({ sql, params, first: true });
       if (!result) return null;
       return this.parseWorkflowRun(result);
     } catch (error$1) {
@@ -1606,6 +2203,312 @@ var D1Store = class extends storage.MastraStorage {
       );
     }
   }
+};
+
+// src/storage/index.ts
+var D1Store = class extends storage.MastraStorage {
+  client;
+  binding;
+  // D1Database binding
+  tablePrefix;
+  stores;
+  /**
+   * Creates a new D1Store instance
+   * @param config Configuration for D1 access (either REST API or Workers Binding API)
+   */
+  constructor(config) {
+    try {
+      super({ name: "D1" });
+      if (config.tablePrefix && !/^[a-zA-Z0-9_]*$/.test(config.tablePrefix)) {
+        throw new Error("Invalid tablePrefix: only letters, numbers, and underscores are allowed.");
+      }
+      this.tablePrefix = config.tablePrefix || "";
+      if ("binding" in config) {
+        if (!config.binding) {
+          throw new Error("D1 binding is required when using Workers Binding API");
+        }
+        this.binding = config.binding;
+        this.logger.info("Using D1 Workers Binding API");
+      } else if ("client" in config) {
+        if (!config.client) {
+          throw new Error("D1 client is required when using D1ClientConfig");
+        }
+        this.client = config.client;
+        this.logger.info("Using D1 Client");
+      } else {
+        if (!config.accountId || !config.databaseId || !config.apiToken) {
+          throw new Error("accountId, databaseId, and apiToken are required when using REST API");
+        }
+        const cfClient = new Cloudflare__default.default({
+          apiToken: config.apiToken
+        });
+        this.client = {
+          query: ({ sql, params }) => {
+            return cfClient.d1.database.query(config.databaseId, {
+              account_id: config.accountId,
+              sql,
+              params
+            });
+          }
+        };
+        this.logger.info("Using D1 REST API");
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_INITIALIZATION_ERROR",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: "Error initializing D1Store"
+        },
+        error$1
+      );
+    }
+    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
+    });
+    this.stores = {
+      operations,
+      scores,
+      legacyEvals,
+      traces,
+      workflows,
+      memory
+    };
+  }
+  get supports() {
+    return {
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: true,
+      createTable: true,
+      deleteMessages: false,
+      getScoresBySpan: true
+    };
+  }
+  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,
+    resourceId,
+    snapshot
+  }) {
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, resourceId, 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 });
+  }
+  async getScoresBySpan({
+    traceId,
+    spanId,
+    pagination
+  }) {
+    return this.stores.scores.getScoresBySpan({ traceId, spanId, pagination });
+  }
   /**
    * Close the database connection
    * No explicit cleanup needed for D1 in either REST or Workers Binding mode
@@ -1613,10 +2516,8 @@ var D1Store = class extends storage.MastraStorage {
   async close() {
     this.logger.debug("Closing D1 connection");
   }
-  async updateMessages(_args) {
-    this.logger.error("updateMessages is not yet implemented in CloudflareD1Store");
-    throw new Error("Method not implemented");
-  }
 };
 
 exports.D1Store = D1Store;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map