@mastra/cloudflare-d1 0.0.0-pg-pool-options-20250428183821 → 0.0.0-pgvector-index-fix-20250905222058

package/dist/index.cjs

@@ -1,15 +1,16 @@
 'use strict';
 
+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');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var Cloudflare__default = /*#__PURE__*/_interopDefault(Cloudflare);
 
 // src/storage/index.ts
-
-// src/storage/sql-builder.ts
 var SqlBuilder = class {
   sql = "";
   params = [];
@@ -19,12 +20,15 @@ var SqlBuilder = class {
     if (!columns || Array.isArray(columns) && columns.length === 0) {
       this.sql = "SELECT *";
     } else {
-      this.sql = `SELECT ${Array.isArray(columns) ? columns.join(", ") : columns}`;
+      const cols = Array.isArray(columns) ? columns : [columns];
+      const parsedCols = cols.map((col) => parseSelectIdentifier(col));
+      this.sql = `SELECT ${parsedCols.join(", ")}`;
     }
     return this;
   }
   from(table) {
-    this.sql += ` FROM ${table}`;
+    const parsedTableName = utils.parseSqlIdentifier(table, "table name");
+    this.sql += ` FROM ${parsedTableName}`;
     return this;
   }
   /**
@@ -61,7 +65,11 @@ var SqlBuilder = class {
     return this;
   }
   orderBy(column, direction = "ASC") {
-    this.sql += ` ORDER BY ${column} ${direction}`;
+    const parsedColumn = utils.parseSqlIdentifier(column, "column name");
+    if (!["ASC", "DESC"].includes(direction)) {
+      throw new Error(`Invalid sort direction: ${direction}`);
+    }
+    this.sql += ` ORDER BY ${parsedColumn} ${direction}`;
     return this;
   }
   limit(count) {
@@ -74,6 +82,10 @@ var SqlBuilder = class {
     this.params.push(count);
     return this;
   }
+  count() {
+    this.sql += "SELECT COUNT(*) AS count";
+    return this;
+  }
   /**
    * Insert a row, or update specific columns on conflict (upsert).
    * @param table Table name
@@ -83,27 +95,33 @@ var SqlBuilder = class {
    * @param updateMap Object mapping columns to update to their new value (e.g. { name: 'excluded.name' })
    */
   insert(table, columns, values, conflictColumns, updateMap) {
-    const placeholders = columns.map(() => "?").join(", ");
+    const parsedTableName = utils.parseSqlIdentifier(table, "table name");
+    const parsedColumns = columns.map((col) => utils.parseSqlIdentifier(col, "column name"));
+    const placeholders = parsedColumns.map(() => "?").join(", ");
     if (conflictColumns && updateMap) {
+      const parsedConflictColumns = conflictColumns.map((col) => utils.parseSqlIdentifier(col, "column name"));
       const updateClause = Object.entries(updateMap).map(([col, expr]) => `${col} = ${expr}`).join(", ");
-      this.sql = `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders}) ON CONFLICT(${conflictColumns.join(", ")}) DO UPDATE SET ${updateClause}`;
+      this.sql = `INSERT INTO ${parsedTableName} (${parsedColumns.join(", ")}) VALUES (${placeholders}) ON CONFLICT(${parsedConflictColumns.join(", ")}) DO UPDATE SET ${updateClause}`;
       this.params.push(...values);
       return this;
     }
-    this.sql = `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders})`;
+    this.sql = `INSERT INTO ${parsedTableName} (${parsedColumns.join(", ")}) VALUES (${placeholders})`;
     this.params.push(...values);
     return this;
   }
   // Update operations
   update(table, columns, values) {
-    const setClause = columns.map((col) => `${col} = ?`).join(", ");
-    this.sql = `UPDATE ${table} SET ${setClause}`;
+    const parsedTableName = utils.parseSqlIdentifier(table, "table name");
+    const parsedColumns = columns.map((col) => utils.parseSqlIdentifier(col, "column name"));
+    const setClause = parsedColumns.map((col) => `${col} = ?`).join(", ");
+    this.sql = `UPDATE ${parsedTableName} SET ${setClause}`;
     this.params.push(...values);
     return this;
   }
   // Delete operations
   delete(table) {
-    this.sql = `DELETE FROM ${table}`;
+    const parsedTableName = utils.parseSqlIdentifier(table, "table name");
+    this.sql = `DELETE FROM ${parsedTableName}`;
     return this;
   }
   /**
@@ -114,9 +132,16 @@ var SqlBuilder = class {
    * @returns The builder instance
    */
   createTable(table, columnDefinitions, tableConstraints) {
-    const columns = columnDefinitions.join(", ");
+    const parsedTableName = utils.parseSqlIdentifier(table, "table name");
+    const parsedColumnDefinitions = columnDefinitions.map((def) => {
+      const colName = def.split(/\s+/)[0];
+      if (!colName) throw new Error("Empty column name in definition");
+      utils.parseSqlIdentifier(colName, "column name");
+      return def;
+    });
+    const columns = parsedColumnDefinitions.join(", ");
     const constraints = tableConstraints && tableConstraints.length > 0 ? ", " + tableConstraints.join(", ") : "";
-    this.sql = `CREATE TABLE IF NOT EXISTS ${table} (${columns}${constraints})`;
+    this.sql = `CREATE TABLE IF NOT EXISTS ${parsedTableName} (${columns}${constraints})`;
     return this;
   }
   /**
@@ -139,13 +164,10 @@ var SqlBuilder = class {
    * @returns The builder instance
    */
   createIndex(indexName, tableName, columnName, indexType = "") {
-    this.sql = `CREATE ${indexType ? indexType + " " : ""}INDEX IF NOT EXISTS ${indexName} ON ${tableName}(${columnName})`;
-    return this;
-  }
-  // Raw SQL with params
-  raw(sql, ...params) {
-    this.sql = sql;
-    this.params.push(...params);
+    const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
+    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+    const parsedColumnName = utils.parseSqlIdentifier(columnName, "column name");
+    this.sql = `CREATE ${indexType ? indexType + " " : ""}INDEX IF NOT EXISTS ${parsedIndexName} ON ${parsedTableName}(${parsedColumnName})`;
     return this;
   }
   /**
@@ -155,11 +177,12 @@ var SqlBuilder = class {
    * @param exact If true, will not add % wildcards
    */
   like(column, value, exact = false) {
+    const parsedColumnName = utils.parseSqlIdentifier(column, "column name");
     const likeValue = exact ? value : `%${value}%`;
     if (this.whereAdded) {
-      this.sql += ` AND ${column} LIKE ?`;
+      this.sql += ` AND ${parsedColumnName} LIKE ?`;
     } else {
-      this.sql += ` WHERE ${column} LIKE ?`;
+      this.sql += ` WHERE ${parsedColumnName} LIKE ?`;
       this.whereAdded = true;
     }
     this.params.push(likeValue);
@@ -172,11 +195,13 @@ var SqlBuilder = class {
    * @param value The value to match
    */
   jsonLike(column, key, value) {
-    const jsonPattern = `%"${key}":"${value}"%`;
+    const parsedColumnName = utils.parseSqlIdentifier(column, "column name");
+    const parsedKey = utils.parseSqlIdentifier(key, "key name");
+    const jsonPattern = `%"${parsedKey}":"${value}"%`;
     if (this.whereAdded) {
-      this.sql += ` AND ${column} LIKE ?`;
+      this.sql += ` AND ${parsedColumnName} LIKE ?`;
     } else {
-      this.sql += ` WHERE ${column} LIKE ?`;
+      this.sql += ` WHERE ${parsedColumnName} LIKE ?`;
       this.whereAdded = true;
     }
     this.params.push(jsonPattern);
@@ -206,331 +231,311 @@ var SqlBuilder = class {
 function createSqlBuilder() {
   return new SqlBuilder();
 }
+var SQL_IDENTIFIER_PATTERN = /^[a-zA-Z0-9_]+(\s+AS\s+[a-zA-Z0-9_]+)?$/;
+function parseSelectIdentifier(column) {
+  if (column !== "*" && !SQL_IDENTIFIER_PATTERN.test(column)) {
+    throw new Error(
+      `Invalid column name: "${column}". Must be "*" or a valid identifier (letters, numbers, underscores), optionally with "AS alias".`
+    );
+  }
+  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) {
-    super({ name: "D1" });
-    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");
-    }
-  }
-  // 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);
+function deserializeValue(value, type) {
+  if (value === null || value === void 0) return null;
+  if (type === "date" && typeof value === "string") {
+    return new Date(value);
   }
-  // Helper method to create SQL indexes for better query performance
-  async createIndexIfNotExists(tableName, columnName, indexType = "") {
-    const fullTableName = this.getTableName(tableName);
-    const indexName = `idx_${tableName}_${columnName}`;
+  if (type === "jsonb" && typeof value === "string") {
     try {
-      const checkQuery = createSqlBuilder().checkIndexExists(indexName, fullTableName);
-      const { sql: checkSql, params: checkParams } = checkQuery.build();
-      const indexExists = await this.executeQuery({
-        sql: checkSql,
-        params: checkParams,
-        first: true
-      });
-      if (!indexExists) {
-        const createQuery = createSqlBuilder().createIndex(indexName, fullTableName, columnName, indexType);
-        const { sql: createSql, params: createParams } = createQuery.build();
-        await this.executeQuery({ sql: createSql, params: createParams });
-        this.logger.debug(`Created index ${indexName} on ${fullTableName}(${columnName})`);
-      }
-    } catch (error) {
-      this.logger.error(`Error creating index on ${fullTableName}(${columnName}):`, {
-        message: error instanceof Error ? error.message : String(error)
-      });
+      return JSON.parse(value);
+    } catch {
+      return value;
     }
   }
-  async executeWorkersBindingQuery({
-    sql,
-    params = [],
-    first = false
-  }) {
-    if (!this.binding) {
-      throw new Error("Workers binding is not configured");
-    }
+  if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
     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}`);
+      return JSON.parse(value);
+    } catch {
+      return value;
     }
   }
-  async executeRestQuery({
-    sql,
-    params = [],
-    first = false
-  }) {
-    if (!this.client || !this.accountId || !this.databaseId) {
-      throw new Error("Missing required REST API configuration");
+  return value;
+}
+
+// src/storage/domains/legacy-evals/index.ts
+var LegacyEvalsStorageD1 = class extends storage.LegacyEvalsStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
+  }
+  async getEvals(options) {
+    const { agentName, type, page = 0, perPage = 40, dateRange } = options || {};
+    const fullTableName = this.operations.getTableName(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 (dateRange?.start) {
+      conditions.push(`created_at >= ?`);
+      queryParams.push(storage.serializeDate(dateRange.start));
     }
+    if (dateRange?.end) {
+      conditions.push(`created_at <= ?`);
+      queryParams.push(storage.serializeDate(dateRange.end));
+    }
+    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 response = await this.client.d1.database.query(this.databaseId, {
-        account_id: this.accountId,
-        sql,
-        params: this.formatSqlParams(params)
+      const countResult = await this.operations.executeQuery({
+        sql: countSql,
+        params: countParams,
+        first: true
       });
-      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;
+      const total = Number(countResult?.count || 0);
+      const currentOffset = page * perPage;
+      if (total === 0) {
+        return {
+          evals: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
       }
-      return results;
-    } catch (restError) {
-      this.logger.error("REST API error", {
-        message: restError instanceof Error ? restError.message : String(restError),
-        sql
+      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
+        };
       });
-      throw new Error(`D1 REST API error: ${restError.message}`);
+      const hasMore = currentOffset + evals.length < total;
+      return {
+        evals,
+        total,
+        page,
+        perPage,
+        hasMore
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_EVALS_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 ?? "" }
+        },
+        error$1
+      );
     }
   }
   /**
-   * 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
+   * @deprecated use getEvals instead
    */
-  async executeQuery(options) {
-    const { sql, params = [], first = false } = options;
+  async getEvalsByAgentName(agentName, type) {
+    const fullTableName = this.operations.getTableName(storage.TABLE_EVALS);
     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");
+      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) {
-      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}`);
-    }
-  }
-  // Helper to convert storage type to SQL type
-  getSqlType(type) {
-    switch (type) {
-      case "text":
-        return "TEXT";
-      case "timestamp":
-        return "TIMESTAMP";
-      case "integer":
-        return "INTEGER";
-      case "bigint":
-        return "INTEGER";
-      // SQLite doesn't have a separate BIGINT type
-      case "jsonb":
-        return "TEXT";
-      // Store JSON as TEXT in SQLite
-      default:
-        return "TEXT";
-    }
-  }
-  ensureDate(date) {
-    if (!date) return void 0;
-    return date instanceof Date ? date : new Date(date);
-  }
-  serializeDate(date) {
-    if (!date) return void 0;
-    const dateObj = this.ensureDate(date);
-    return dateObj?.toISOString();
-  }
-  // 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);
+      query.orderBy("created_at", "DESC");
+      const { sql, params } = query.build();
+      const results = await this.operations.executeQuery({ sql, params });
+      return isArrayOfRecords(results) ? results.map((row) => {
+        const result = deserializeValue(row.result);
+        const testInfo = row.test_info ? deserializeValue(row.test_info) : void 0;
+        return {
+          input: row.input || "",
+          output: row.output || "",
+          result,
+          agentName: row.agent_name || "",
+          metricName: row.metric_name || "",
+          instructions: row.instructions || "",
+          runId: row.run_id || "",
+          globalRunId: row.global_run_id || "",
+          createdAt: row.created_at || "",
+          testInfo
+        };
+      }) : [];
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_EVALS_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 }
+        },
+        error$1
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return [];
     }
-    return value;
   }
-  // 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);
-    }
-    if (type === "jsonb" && typeof value === "string") {
-      try {
-        return JSON.parse(value);
-      } catch {
-        return value;
-      }
-    }
-    if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
-      try {
-        return JSON.parse(value);
-      } catch {
-        return value;
-      }
-    }
-    return value;
+};
+var MemoryStorageD1 = class extends storage.MemoryStorage {
+  operations;
+  constructor({ operations }) {
+    super();
+    this.operations = operations;
   }
-  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();
+  async getResourceById({ resourceId }) {
+    const resource = await this.operations.load({
+      tableName: storage.TABLE_RESOURCES,
+      keys: { id: resourceId }
     });
-    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();
-    try {
-      await this.executeQuery({ sql, params });
-      this.logger.debug(`Created table ${fullTableName}`);
-    } catch (error) {
-      this.logger.error(`Error creating table ${fullTableName}:`, {
-        message: error instanceof Error ? error.message : String(error)
-      });
-      throw new Error(`Failed to create table ${fullTableName}: ${error}`);
-    }
-  }
-  async clearTable({ tableName }) {
-    const fullTableName = this.getTableName(tableName);
+    if (!resource) return null;
     try {
-      const query = createSqlBuilder().delete(fullTableName);
-      const { sql, params } = query.build();
-      await this.executeQuery({ sql, params });
-      this.logger.debug(`Cleared table ${fullTableName}`);
-    } catch (error) {
-      this.logger.error(`Error clearing table ${fullTableName}:`, {
-        message: error instanceof Error ? error.message : String(error)
-      });
-      throw new Error(`Failed to clear table ${fullTableName}: ${error}`);
-    }
-  }
-  async processRecord(record) {
-    const processedRecord = {};
-    for (const [key, value] of Object.entries(record)) {
-      processedRecord[key] = this.serializeValue(value);
+      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 });
-    } catch (error) {
-      this.logger.error(`Error inserting into ${fullTableName}:`, { error });
-      throw new Error(`Failed to insert into ${fullTableName}: ${error}`);
+      await this.operations.executeQuery({ sql, params });
+      return resource;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_SAVE_RESOURCE_ERROR",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          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;
-    } catch (error) {
-      this.logger.error(`Error loading from ${fullTableName}:`, {
-        message: error instanceof Error ? error.message : String(error)
-      });
-      return null;
+      await this.operations.executeQuery({ sql, params });
+      return updatedResource;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_UPDATE_RESOURCE_ERROR",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          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 }
     });
@@ -538,47 +543,113 @@ 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) {
-      this.logger.error(`Error processing thread ${threadId}:`, {
-        message: error instanceof Error ? error.message : String(error)
-      });
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_THREAD_BY_ID_ERROR",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Error processing thread ${threadId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { threadId }
+        },
+        error$1
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return null;
     }
   }
+  /**
+   * @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) {
-      this.logger.error(`Error getting threads by resourceId ${resourceId}:`, {
-        message: error instanceof Error ? error.message : String(error)
-      });
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_THREADS_BY_RESOURCE_ID_ERROR",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Error getting threads by resourceId ${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 [];
     }
   }
+  async getThreadsByResourceIdPaginated(args) {
+    const { resourceId, page, perPage } = args;
+    const fullTableName = this.operations.getTableName(storage.TABLE_THREADS);
+    const mapRowToStorageThreadType = (row) => ({
+      ...row,
+      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.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.operations.executeQuery(selectQuery.build());
+      const threads = results.map(mapRowToStorageThreadType);
+      return {
+        threads,
+        total,
+        page,
+        perPage,
+        hasMore: page * perPage + threads.length < total
+      };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_ERROR",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Error getting threads by resourceId ${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 {
+        threads: [],
+        total: 0,
+        page,
+        perPage,
+        hasMore: false
+      };
+    }
+  }
   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 = {
@@ -591,11 +662,19 @@ 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) {
-      this.logger.error(`Error saving thread to ${fullTableName}:`, { error });
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_SAVE_THREAD_ERROR",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Failed to save thread to ${fullTableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { threadId: thread.id }
+        },
+        error$1
+      );
     }
   }
   async updateThread({
@@ -604,20 +683,21 @@ var D1Store = class extends storage.MastraStorage {
     metadata
   }) {
     const thread = await this.getThreadById({ threadId: id });
-    if (!thread) {
-      throw new Error(`Thread ${id} not found`);
-    }
-    const fullTableName = this.getTableName(storage.TABLE_THREADS);
-    const mergedMetadata = {
-      ...typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-      ...metadata
-    };
-    const columns = ["title", "metadata", "updatedAt"];
-    const values = [title, JSON.stringify(mergedMetadata), (/* @__PURE__ */ new Date()).toISOString()];
-    const query = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", id);
-    const { sql, params } = query.build();
     try {
-      await this.executeQuery({ sql, params });
+      if (!thread) {
+        throw new Error(`Thread ${id} not found`);
+      }
+      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), updatedAt.toISOString()];
+      const query = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", id);
+      const { sql, params } = query.build();
+      await this.operations.executeQuery({ sql, params });
       return {
         ...thread,
         title,
@@ -625,40 +705,64 @@ var D1Store = class extends storage.MastraStorage {
           ...typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
           ...metadata
         },
-        updatedAt: /* @__PURE__ */ new Date()
+        updatedAt
       };
-    } catch (error) {
-      this.logger.error("Error updating thread:", { error });
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_UPDATE_THREAD_ERROR",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Failed to update thread ${id}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { threadId: id }
+        },
+        error$1
+      );
     }
   }
   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 });
-    } catch (error) {
-      this.logger.error(`Error deleting thread ${threadId}:`, {
-        message: error instanceof Error ? error.message : String(error)
-      });
-      throw new Error(`Failed to delete thread ${threadId}: ${error}`);
+      await this.operations.executeQuery({ sql: messagesSql, params: messagesParams });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_DELETE_THREAD_ERROR",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Failed to delete thread ${threadId}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { threadId }
+        },
+        error$1
+      );
     }
   }
-  // Thread and message management methods
-  async saveMessages({ messages }) {
+  async saveMessages(args) {
+    const { messages, format = "v1" } = args;
     if (messages.length === 0) return [];
     try {
       const now = /* @__PURE__ */ new Date();
+      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`);
@@ -672,74 +776,122 @@ var D1Store = class extends storage.MastraStorage {
           content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
           createdAt: createdAt.toISOString(),
           role: message.role,
-          type: message.type
+          type: message.type || "v2",
+          resourceId: message.resourceId
         };
       });
-      await this.batchInsert({
-        tableName: storage.TABLE_MESSAGES,
-        records: messagesToInsert
-      });
+      await Promise.all([
+        this.operations.batchUpsert({
+          tableName: storage.TABLE_MESSAGES,
+          records: messagesToInsert
+        }),
+        // Update thread's updatedAt timestamp
+        this.operations.executeQuery({
+          sql: `UPDATE ${this.operations.getTableName(storage.TABLE_THREADS)} SET updatedAt = ? WHERE id = ?`,
+          params: [now.toISOString(), threadId]
+        })
+      ]);
       this.logger.debug(`Saved ${messages.length} messages`);
-      return messages;
-    } catch (error) {
-      this.logger.error("Error saving messages:", { message: error instanceof Error ? error.message : String(error) });
-      throw error;
+      const list = new agent.MessageList().add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_SAVE_MESSAGES_ERROR",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Failed to save messages: ${error$1 instanceof Error ? error$1.message : String(error$1)}`
+        },
+        error$1
+      );
     }
   }
-  async getMessages({ threadId, selectBy }) {
-    const fullTableName = this.getTableName(storage.TABLE_MESSAGES);
-    const limit = typeof selectBy?.last === "number" ? selectBy.last : 40;
-    const include = selectBy?.include || [];
-    const messages = [];
+  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 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
+  }) {
     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 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 sql2 = `
-        WITH ordered_messages AS (
-          SELECT
-            *,
-            ROW_NUMBER() OVER (ORDER BY createdAt DESC) AS row_num
-          FROM ${fullTableName}
-          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 params2 = [
-          threadId,
-          ...includeIds,
-          // for m.id IN (...)
-          ...includeIds,
-          // for target.id IN (...)
-          prevMax,
-          nextMax
-        ];
-        const includeResult = await this.executeQuery({ sql: sql2, params: params2 });
+        const includeResult = await this._getIncludedMessages(threadId, selectBy);
         if (Array.isArray(includeResult)) messages.push(...includeResult);
       }
       const excludeIds = messages.map((m) => m.id);
-      let query = createSqlBuilder().select(["id", "content", "role", "type", '"createdAt"', 'thread_id AS "threadId"']).from(fullTableName).where("thread_id = ?", threadId).andWhere(`id NOT IN (${excludeIds.map(() => "?").join(",")})`, ...excludeIds).orderBy("createdAt", "DESC").limit(limit);
+      const query = createSqlBuilder().select(["id", "content", "role", "type", "createdAt", "thread_id AS threadId"]).from(fullTableName).where("thread_id = ?", threadId);
+      if (excludeIds.length > 0) {
+        query.andWhere(`id NOT IN (${excludeIds.map(() => "?").join(",")})`, ...excludeIds);
+      }
+      query.orderBy("createdAt", "DESC").limit(limit);
       const { 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;
@@ -751,186 +903,1539 @@ var D1Store = class extends storage.MastraStorage {
       const processedMessages = messages.map((message) => {
         const processedMsg = {};
         for (const [key, value] of Object.entries(message)) {
-          processedMsg[key] = this.deserializeValue(value);
+          if (key === `type` && value === `v2`) continue;
+          processedMsg[key] = deserializeValue(value);
         }
         return processedMsg;
       });
       this.logger.debug(`Retrieved ${messages.length} messages for thread ${threadId}`);
-      return processedMessages;
-    } catch (error) {
-      this.logger.error("Error retrieving messages for thread", {
-        threadId,
-        message: error instanceof Error ? error.message : String(error)
-      });
-      return [];
+      const list = new agent.MessageList().add(processedMessages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_MESSAGES_ERROR",
+          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, resourceId: resourceId ?? "" }
+        },
+        error$1
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     }
   }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    snapshot
+  async getMessagesById({
+    messageIds,
+    format
   }) {
-    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();
+    if (messageIds.length === 0) return [];
+    const fullTableName = this.operations.getTableName(storage.TABLE_MESSAGES);
+    const messages = [];
     try {
-      await this.executeQuery({ sql, params });
-    } catch (error) {
-      this.logger.error("Error persisting workflow snapshot:", {
-        message: error instanceof Error ? error.message : String(error)
+      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;
       });
-      throw error;
+      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
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     }
   }
-  async loadWorkflowSnapshot(params) {
-    const { workflowName, runId } = params;
-    this.logger.debug("Loading workflow snapshot", { workflowName, runId });
-    const d = await this.load({
-      tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
-      keys: {
-        workflow_name: workflowName,
-        run_id: runId
+  async getMessagesPaginated({
+    threadId,
+    resourceId,
+    selectBy,
+    format
+  }) {
+    const { dateRange, page = 0, perPage: perPageInput } = selectBy?.pagination || {};
+    const { start: fromDate, end: toDate } = dateRange || {};
+    const perPage = perPageInput !== void 0 ? perPageInput : 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);
       }
-    });
-    return d ? d.snapshot : null;
+      const countQuery = createSqlBuilder().count().from(fullTableName).where("thread_id = ?", threadId);
+      if (fromDate) {
+        countQuery.andWhere("createdAt >= ?", storage.serializeDate(fromDate));
+      }
+      if (toDate) {
+        countQuery.andWhere("createdAt <= ?", storage.serializeDate(toDate));
+      }
+      const countResult = await this.operations.executeQuery(countQuery.build());
+      const total = Number(countResult[0]?.count ?? 0);
+      if (total === 0 && messages.length === 0) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const excludeIds = messages.map((m) => m.id);
+      const excludeCondition = excludeIds.length > 0 ? `AND id NOT IN (${excludeIds.map(() => "?").join(",")})` : "";
+      let query;
+      let queryParams = [threadId];
+      if (fromDate) {
+        queryParams.push(storage.serializeDate(fromDate));
+      }
+      if (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());
+      }
+      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: selectBy?.last ? false : page * perPage + messages.length < total
+      };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_MESSAGES_PAGINATED_ERROR",
+          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, resourceId: resourceId ?? "" }
+        },
+        error$1
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage,
+        hasMore: false
+      };
+    }
   }
-  /**
-   * 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 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 {
-      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 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 {
           }
         }
-        this.logger.debug(
-          `Processed batch ${Math.floor(i / batchSize) + 1} of ${Math.ceil(records.length / batchSize)}`
-        );
+        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 });
+        }
       }
-      this.logger.debug(`Successfully batch inserted ${records.length} records into ${tableName}`);
-    } catch (error) {
-      this.logger.error(`Error batch inserting into ${tableName}:`, {
-        message: error instanceof Error ? error.message : String(error)
+      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;
       });
-      throw new Error(`Failed to batch insert into ${tableName}: ${error}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_UPDATE_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { count: messages.length }
+        },
+        error$1
+      );
     }
   }
-  async getTraces({
-    name,
-    scope,
-    page,
-    perPage,
-    attributes
+};
+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
   }) {
-    const fullTableName = this.getTableName(storage.TABLE_TRACES);
+    if (!this.binding) {
+      throw new Error("Workers binding is not configured");
+    }
     try {
-      const query = createSqlBuilder().select("*").from(fullTableName).where("1=1");
-      if (name) {
-        query.andWhere("name LIKE ?", `%${name}%`);
-      }
-      if (scope) {
-        query.andWhere("scope = ?", scope);
-      }
-      if (attributes && Object.keys(attributes).length > 0) {
-        for (const [key, value] of Object.entries(attributes)) {
-          query.jsonLike("attributes", key, value);
+      const statement = this.binding.prepare(sql);
+      const formattedParams = this.formatSqlParams(params);
+      let result;
+      if (formattedParams.length > 0) {
+        if (first) {
+          result = await statement.bind(...formattedParams).first();
+          if (!result) return null;
+          return result;
+        } else {
+          result = await statement.bind(...formattedParams).all();
+          const results = result.results || [];
+          return results;
+        }
+      } else {
+        if (first) {
+          result = await statement.first();
+          if (!result) return null;
+          return result;
+        } else {
+          result = await statement.all();
+          const results = result.results || [];
+          return results;
         }
       }
-      query.orderBy("startTime", "DESC").limit(perPage).offset((page - 1) * 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")
-      })) : [];
-    } catch (error) {
-      this.logger.error("Error getting traces:", { message: error instanceof Error ? error.message : String(error) });
-      return [];
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORE_OPERATIONS_WORKERS_BINDING_QUERY_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { sql }
+        },
+        error$1
+      );
     }
   }
-  async getEvalsByAgentName(agentName, type) {
-    const fullTableName = this.getTableName(storage.TABLE_EVALS);
+  async executeRestQuery({
+    sql,
+    params = [],
+    first = false
+  }) {
+    if (!this.client) {
+      throw new Error("D1 client is not configured");
+    }
     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)");
+      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;
       }
-      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
-        };
-      }) : [];
+      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.error(`Error getting evals for agent ${agentName}:`, {
-        message: error instanceof Error ? error.message : String(error)
-      });
+      this.logger.warn(`Failed to get table columns for ${tableName}:`, error);
       return [];
     }
   }
-  getWorkflowRuns(_args) {
-    throw new Error("Method not implemented.");
+  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}`);
+        }
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          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,
+          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 }) {
+    if (records.length === 0) return;
+    const fullTableName = this.getTableName(tableName);
+    try {
+      const batchSize = 50;
+      for (let i = 0; i < records.length; i += batchSize) {
+        const batch = records.slice(i, i + batchSize);
+        const recordsToInsert = batch;
+        if (recordsToInsert.length > 0) {
+          const firstRecord = recordsToInsert[0];
+          const columns = Object.keys(firstRecord || {});
+          for (const record of recordsToInsert) {
+            const values = columns.map((col) => {
+              if (!record) return null;
+              const value = typeof col === "string" ? record[col] : null;
+              return this.serializeValue(value);
+            });
+            const recordToUpsert = columns.reduce(
+              (acc, col) => {
+                if (col !== "createdAt") acc[col] = `excluded.${col}`;
+                return acc;
+              },
+              {}
+            );
+            const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], recordToUpsert);
+            const { sql, params } = query.build();
+            await this.executeQuery({ sql, params });
+          }
+        }
+        this.logger.debug(
+          `Processed batch ${Math.floor(i / batchSize) + 1} of ${Math.ceil(records.length / batchSize)}`
+        );
+      }
+      this.logger.debug(`Successfully batch upserted ${records.length} records into ${tableName}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_BATCH_UPSERT_ERROR",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Failed to batch upsert into ${tableName}: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+};
+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) {
+    try {
+      const id = crypto.randomUUID();
+      const fullTableName = this.operations.getTableName(storage.TABLE_SCORERS);
+      const { input, ...rest } = score;
+      const serializedRecord = {};
+      for (const [key, value] of Object.entries(rest)) {
+        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.input = JSON.stringify(input);
+      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
+  }) {
+    try {
+      const fullTableName = this.operations.getTableName(storage.TABLE_SCORERS);
+      const countQuery = createSqlBuilder().count().from(fullTableName).where("scorerId = ?", scorerId);
+      if (entityId) {
+        countQuery.andWhere("entityId = ?", entityId);
+      }
+      if (entityType) {
+        countQuery.andWhere("entityType = ?", entityType);
+      }
+      if (source) {
+        countQuery.andWhere("source = ?", source);
+      }
+      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("scorerId = ?", scorerId);
+      if (entityId) {
+        selectQuery.andWhere("entityId = ?", entityId);
+      }
+      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) {
+      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
+      );
+    }
+  }
+};
+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: args.name ?? "",
+            scope: args.scope ?? ""
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async getTracesPaginated(args) {
+    const { name, scope, page = 0, perPage = 100, attributes, dateRange } = args;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const fullTableName = this.operations.getTableName(storage.TABLE_TRACES);
+    try {
+      const dataQuery = createSqlBuilder().select("*").from(fullTableName).where("1=1");
+      const countQuery = createSqlBuilder().count().from(fullTableName).where("1=1");
+      if (name) {
+        dataQuery.andWhere("name LIKE ?", `%${name}%`);
+        countQuery.andWhere("name LIKE ?", `%${name}%`);
+      }
+      if (scope) {
+        dataQuery.andWhere("scope = ?", scope);
+        countQuery.andWhere("scope = ?", scope);
+      }
+      if (attributes && Object.keys(attributes).length > 0) {
+        for (const [key, value] of Object.entries(attributes)) {
+          dataQuery.jsonLike("attributes", key, value);
+          countQuery.jsonLike("attributes", key, value);
+        }
+      }
+      if (fromDate) {
+        const fromDateStr = fromDate instanceof Date ? fromDate.toISOString() : fromDate;
+        dataQuery.andWhere("createdAt >= ?", fromDateStr);
+        countQuery.andWhere("createdAt >= ?", fromDateStr);
+      }
+      if (toDate) {
+        const toDateStr = toDate instanceof Date ? toDate.toISOString() : toDate;
+        dataQuery.andWhere("createdAt <= ?", toDateStr);
+        countQuery.andWhere("createdAt <= ?", toDateStr);
+      }
+      const allDataResult = await this.operations.executeQuery(
+        createSqlBuilder().select("*").from(fullTableName).where("1=1").build()
+      );
+      console.log("allDataResult", allDataResult);
+      const countResult = await this.operations.executeQuery(countQuery.build());
+      const total = Number(countResult?.[0]?.count ?? 0);
+      dataQuery.orderBy("startTime", "DESC").limit(perPage).offset(page * perPage);
+      const results = await this.operations.executeQuery(dataQuery.build());
+      const traces = isArrayOfRecords2(results) ? results.map(
+        (trace) => ({
+          ...trace,
+          attributes: deserializeValue(trace.attributes, "jsonb"),
+          status: deserializeValue(trace.status, "jsonb"),
+          events: deserializeValue(trace.events, "jsonb"),
+          links: deserializeValue(trace.links, "jsonb"),
+          other: deserializeValue(trace.other, "jsonb")
+        })
+      ) : [];
+      return {
+        traces,
+        total,
+        page,
+        perPage,
+        hasMore: page * perPage + traces.length < total
+      };
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          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)}`,
+          details: { name: name ?? "", scope: scope ?? "" }
+        },
+        error$1
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return { traces: [], total: 0, page, perPage, hasMore: false };
+    }
+  }
+  async batchTraceInsert({ records }) {
+    this.logger.debug("Batch inserting traces", { count: records.length });
+    await this.operations.batchInsert({
+      tableName: 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,
+    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,
+      snapshot: JSON.stringify(snapshot),
+      updatedAt: now
+    } : {
+      workflow_name: workflowName,
+      run_id: runId,
+      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 {
+      await this.operations.executeQuery({ sql, params });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_PERSIST_WORKFLOW_SNAPSHOT_ERROR",
+          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 }
+        },
+        error$1
+      );
+    }
+  }
+  async loadWorkflowSnapshot(params) {
+    const { workflowName, runId } = params;
+    this.logger.debug("Loading workflow snapshot", { workflowName, runId });
+    try {
+      const d = await this.operations.load({
+        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+        keys: {
+          workflow_name: workflowName,
+          run_id: runId
+        }
+      });
+      return d ? d.snapshot : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_LOAD_WORKFLOW_SNAPSHOT_ERROR",
+          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 }
+        },
+        error$1
+      );
+    }
+  }
+  parseWorkflowRun(row) {
+    let parsedSnapshot = row.snapshot;
+    if (typeof parsedSnapshot === "string") {
+      try {
+        parsedSnapshot = JSON.parse(row.snapshot);
+      } catch (e) {
+        console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+      }
+    }
+    return {
+      workflowName: row.workflow_name,
+      runId: row.run_id,
+      snapshot: parsedSnapshot,
+      createdAt: storage.ensureDate(row.createdAt),
+      updatedAt: storage.ensureDate(row.updatedAt),
+      resourceId: row.resourceId
+    };
+  }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset,
+    resourceId
+  } = {}) {
+    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.operations.hasColumn(fullTableName, "resourceId");
+        if (hasResourceId) {
+          builder.whereAnd("resourceId = ?", resourceId);
+          countBuilder.whereAnd("resourceId = ?", resourceId);
+        } else {
+          console.warn(`[${fullTableName}] resourceId column not found. Skipping resourceId filter.`);
+        }
+      }
+      if (fromDate) {
+        builder.whereAnd("createdAt >= ?", fromDate instanceof Date ? fromDate.toISOString() : fromDate);
+        countBuilder.whereAnd("createdAt >= ?", fromDate instanceof Date ? fromDate.toISOString() : fromDate);
+      }
+      if (toDate) {
+        builder.whereAnd("createdAt <= ?", toDate instanceof Date ? toDate.toISOString() : toDate);
+        countBuilder.whereAnd("createdAt <= ?", toDate instanceof Date ? toDate.toISOString() : toDate);
+      }
+      builder.orderBy("createdAt", "DESC");
+      if (typeof limit === "number") builder.limit(limit);
+      if (typeof offset === "number") builder.offset(offset);
+      const { sql, params } = builder.build();
+      let total = 0;
+      if (limit !== void 0 && offset !== void 0) {
+        const { sql: countSql, params: countParams } = countBuilder.build();
+        const countResult = await this.operations.executeQuery({
+          sql: countSql,
+          params: countParams,
+          first: true
+        });
+        total = Number(countResult?.count ?? 0);
+      }
+      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) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_WORKFLOW_RUNS_ERROR",
+          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 ?? ""
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    const fullTableName = this.operations.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
+    try {
+      const conditions = [];
+      const params = [];
+      if (runId) {
+        conditions.push("run_id = ?");
+        params.push(runId);
+      }
+      if (workflowName) {
+        conditions.push("workflow_name = ?");
+        params.push(workflowName);
+      }
+      const whereClause = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
+      const sql = `SELECT * FROM ${fullTableName} ${whereClause} ORDER BY createdAt DESC LIMIT 1`;
+      const result = await this.operations.executeQuery({ sql, params, first: true });
+      if (!result) return null;
+      return this.parseWorkflowRun(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_WORKFLOW_RUN_BY_ID_ERROR",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          text: `Failed to retrieve workflow run by ID: ${error$1 instanceof Error ? error$1.message : String(error$1)}`,
+          details: { runId, workflowName: workflowName ?? "" }
+        },
+        error$1
+      );
+    }
+  }
+};
+
+// 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
+    };
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    return this.stores.operations.createTable({ tableName, schema });
+  }
+  /**
+   * Alters table schema to add columns if they don't exist
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists
+  }) {
+    return this.stores.operations.alterTable({ tableName, schema, ifNotExists });
+  }
+  async clearTable({ tableName }) {
+    return this.stores.operations.clearTable({ tableName });
+  }
+  async dropTable({ tableName }) {
+    return this.stores.operations.dropTable({ tableName });
+  }
+  async hasColumn(table, column) {
+    return this.stores.operations.hasColumn(table, column);
+  }
+  async insert({ tableName, record }) {
+    return this.stores.operations.insert({ tableName, record });
+  }
+  async load({ tableName, keys }) {
+    return this.stores.operations.load({ tableName, keys });
+  }
+  async getThreadById({ threadId }) {
+    return this.stores.memory.getThreadById({ threadId });
+  }
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead
+   */
+  async getThreadsByResourceId({ resourceId }) {
+    return this.stores.memory.getThreadsByResourceId({ resourceId });
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    return this.stores.memory.getThreadsByResourceIdPaginated(args);
+  }
+  async saveThread({ thread }) {
+    return this.stores.memory.saveThread({ thread });
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    return this.stores.memory.updateThread({ id, title, metadata });
+  }
+  async deleteThread({ threadId }) {
+    return this.stores.memory.deleteThread({ threadId });
+  }
+  async saveMessages(args) {
+    return this.stores.memory.saveMessages(args);
+  }
+  async getMessages({
+    threadId,
+    selectBy,
+    format
+  }) {
+    return this.stores.memory.getMessages({ threadId, selectBy, format });
+  }
+  async getMessagesById({
+    messageIds,
+    format
+  }) {
+    return this.stores.memory.getMessagesById({ messageIds, format });
+  }
+  async getMessagesPaginated({
+    threadId,
+    selectBy,
+    format
+  }) {
+    return this.stores.memory.getMessagesPaginated({ threadId, selectBy, format });
+  }
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    runtimeContext
+  }) {
+    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, runtimeContext });
+  }
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
+  }) {
+    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
+  }
+  async loadWorkflowSnapshot(params) {
+    return this.stores.workflows.loadWorkflowSnapshot(params);
+  }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset,
+    resourceId
+  } = {}) {
+    return this.stores.workflows.getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId });
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
+  }
+  /**
+   * Insert multiple records in a batch operation
+   * @param tableName The table to insert into
+   * @param records The records to insert
+   */
+  async batchInsert({ tableName, records }) {
+    return this.stores.operations.batchInsert({ tableName, records });
+  }
+  /**
+   * @deprecated use getTracesPaginated instead
+   */
+  async getTraces(args) {
+    return this.stores.traces.getTraces(args);
+  }
+  async getTracesPaginated(args) {
+    return this.stores.traces.getTracesPaginated(args);
+  }
+  /**
+   * @deprecated use getEvals instead
+   */
+  async getEvalsByAgentName(agentName, type) {
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
+  }
+  async getEvals(options) {
+    return this.stores.legacyEvals.getEvals(options);
+  }
+  async updateMessages(_args) {
+    return this.stores.memory.updateMessages(_args);
+  }
+  async getResourceById({ resourceId }) {
+    return this.stores.memory.getResourceById({ resourceId });
+  }
+  async saveResource({ resource }) {
+    return this.stores.memory.saveResource({ resource });
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
+  }
+  async getScoreById({ id: _id }) {
+    return this.stores.scores.getScoreById({ id: _id });
+  }
+  async saveScore(_score) {
+    return this.stores.scores.saveScore(_score);
+  }
+  async getScoresByRunId({
+    runId: _runId,
+    pagination: _pagination
+  }) {
+    return this.stores.scores.getScoresByRunId({ runId: _runId, pagination: _pagination });
+  }
+  async getScoresByEntityId({
+    entityId: _entityId,
+    entityType: _entityType,
+    pagination: _pagination
+  }) {
+    return this.stores.scores.getScoresByEntityId({
+      entityId: _entityId,
+      entityType: _entityType,
+      pagination: _pagination
+    });
+  }
+  async getScoresByScorerId({
+    scorerId,
+    pagination,
+    entityId,
+    entityType,
+    source
+  }) {
+    return this.stores.scores.getScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
   }
   /**
    * Close the database connection
@@ -942,3 +2447,5 @@ var D1Store = class extends storage.MastraStorage {
 };
 
 exports.D1Store = D1Store;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map