@mastra/cloudflare-d1 0.0.0-switch-to-core-20250424015131 → 0.0.0-tool-call-parts-20250630193309

package/dist/index.js

@@ -1,9 +1,10 @@
+import { MessageList } from '@mastra/core/agent';
+import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { MastraStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_WORKFLOW_SNAPSHOT, TABLE_TRACES, TABLE_EVALS } from '@mastra/core/storage';
 import Cloudflare from 'cloudflare';
+import { parseSqlIdentifier } from '@mastra/core/utils';
 
 // src/storage/index.ts
-
-// src/storage/sql-builder.ts
 var SqlBuilder = class {
   sql = "";
   params = [];
@@ -13,12 +14,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 = parseSqlIdentifier(table, "table name");
+    this.sql += ` FROM ${parsedTableName}`;
     return this;
   }
   /**
@@ -55,7 +59,11 @@ var SqlBuilder = class {
     return this;
   }
   orderBy(column, direction = "ASC") {
-    this.sql += ` ORDER BY ${column} ${direction}`;
+    const parsedColumn = 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) {
@@ -68,6 +76,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
@@ -77,27 +89,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 = parseSqlIdentifier(table, "table name");
+    const parsedColumns = columns.map((col) => parseSqlIdentifier(col, "column name"));
+    const placeholders = parsedColumns.map(() => "?").join(", ");
     if (conflictColumns && updateMap) {
+      const parsedConflictColumns = conflictColumns.map((col) => 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 = parseSqlIdentifier(table, "table name");
+    const parsedColumns = columns.map((col) => 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 = parseSqlIdentifier(table, "table name");
+    this.sql = `DELETE FROM ${parsedTableName}`;
     return this;
   }
   /**
@@ -108,9 +126,16 @@ var SqlBuilder = class {
    * @returns The builder instance
    */
   createTable(table, columnDefinitions, tableConstraints) {
-    const columns = columnDefinitions.join(", ");
+    const parsedTableName = 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");
+      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;
   }
   /**
@@ -133,13 +158,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 = parseSqlIdentifier(indexName, "index name");
+    const parsedTableName = parseSqlIdentifier(tableName, "table name");
+    const parsedColumnName = parseSqlIdentifier(columnName, "column name");
+    this.sql = `CREATE ${indexType ? indexType + " " : ""}INDEX IF NOT EXISTS ${parsedIndexName} ON ${parsedTableName}(${parsedColumnName})`;
     return this;
   }
   /**
@@ -149,11 +171,12 @@ var SqlBuilder = class {
    * @param exact If true, will not add % wildcards
    */
   like(column, value, exact = false) {
+    const parsedColumnName = 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);
@@ -166,11 +189,13 @@ var SqlBuilder = class {
    * @param value The value to match
    */
   jsonLike(column, key, value) {
-    const jsonPattern = `%"${key}":"${value}"%`;
+    const parsedColumnName = parseSqlIdentifier(column, "column name");
+    const parsedKey = 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);
@@ -200,6 +225,15 @@ 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
 function isArrayOfRecords(value) {
@@ -217,24 +251,39 @@ var D1Store = class extends MastraStorage {
    * @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");
+    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.accountId = config.accountId;
-      this.databaseId = config.databaseId;
-      this.client = new Cloudflare({
-        apiToken: config.apiToken
-      });
-      this.logger.info("Using D1 REST API");
+      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({
+          apiToken: config.apiToken
+        });
+        this.logger.info("Using D1 REST API");
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_INITIALIZATION_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.SYSTEM,
+          text: "Error initializing D1Store"
+        },
+        error
+      );
     }
   }
   // Helper method to get the full table name with prefix
@@ -244,30 +293,6 @@ var D1Store = class extends MastraStorage {
   formatSqlParams(params) {
     return params.map((p) => p === void 0 || p === null ? null : p);
   }
-  // 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}`;
-    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)
-      });
-    }
-  }
   async executeWorkersBindingQuery({
     sql,
     params = [],
@@ -371,34 +396,25 @@ var D1Store = class extends MastraStorage {
       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";
+  // Helper to get existing table columns
+  async getTableColumns(tableName) {
+    try {
+      const sql = `PRAGMA table_info(${tableName})`;
+      const result = await this.executeQuery({ sql, params: [] });
+      if (!result || !Array.isArray(result)) {
+        return [];
+      }
+      return result.map((row) => ({
+        name: row.name,
+        type: row.type
+      }));
+    } catch (error) {
+      this.logger.error(`Error getting table columns for ${tableName}:`, {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return [];
     }
   }
-  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;
@@ -432,6 +448,18 @@ var D1Store = class extends MastraStorage {
     }
     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
@@ -447,16 +475,64 @@ var D1Store = class extends MastraStorage {
     if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
       tableConstraints.push("UNIQUE (workflow_name, run_id)");
     }
-    const query = createSqlBuilder().createTable(fullTableName, columnDefinitions, tableConstraints);
-    const { sql, params } = query.build();
     try {
+      const query = createSqlBuilder().createTable(fullTableName, columnDefinitions, tableConstraints);
+      const { sql, params } = query.build();
       await this.executeQuery({ sql, params });
       this.logger.debug(`Created table ${fullTableName}`);
     } catch (error) {
       this.logger.error(`Error creating table ${fullTableName}:`, {
         message: error instanceof Error ? error.message : String(error)
       });
-      throw new Error(`Failed to create table ${fullTableName}: ${error}`);
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_CREATE_TABLE_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to create table ${fullTableName}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  /**
+   * Alters table schema to add columns if they don't exist
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists
+  }) {
+    const fullTableName = this.getTableName(tableName);
+    try {
+      const existingColumns = await this.getTableColumns(fullTableName);
+      const existingColumnNames = new Set(existingColumns.map((col) => col.name.toLowerCase()));
+      for (const columnName of ifNotExists) {
+        if (!existingColumnNames.has(columnName.toLowerCase()) && schema[columnName]) {
+          const columnDef = schema[columnName];
+          const sqlType = this.getSqlType(columnDef.type);
+          const nullable = columnDef.nullable === false ? "NOT NULL" : "";
+          const defaultValue = columnDef.nullable === false ? this.getDefaultValue(columnDef.type) : "";
+          const alterSql = `ALTER TABLE ${fullTableName} ADD COLUMN ${columnName} ${sqlType} ${nullable} ${defaultValue}`.trim();
+          await this.executeQuery({ sql: alterSql, params: [] });
+          this.logger.debug(`Added column ${columnName} to table ${fullTableName}`);
+        }
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_ALTER_TABLE_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to alter table ${fullTableName}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   async clearTable({ tableName }) {
@@ -467,10 +543,16 @@ var D1Store = class extends MastraStorage {
       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}`);
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_CLEAR_TABLE_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to clear table ${fullTableName}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   async processRecord(record) {
@@ -490,8 +572,16 @@ var D1Store = class extends MastraStorage {
     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}`);
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_INSERT_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to insert into ${fullTableName}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   async load({ tableName, keys }) {
@@ -517,10 +607,16 @@ var D1Store = class extends MastraStorage {
       }
       return processedResult;
     } catch (error) {
-      this.logger.error(`Error loading from ${fullTableName}:`, {
-        message: error instanceof Error ? error.message : String(error)
-      });
-      return null;
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_LOAD_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to load from ${fullTableName}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   async getThreadById({ threadId }) {
@@ -537,12 +633,24 @@ var D1Store = class extends MastraStorage {
         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)
-      });
+      const mastraError = new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_THREAD_BY_ID_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Error processing thread ${threadId}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { threadId }
+        },
+        error
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return null;
     }
   }
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead
+   */
   async getThreadsByResourceId({ resourceId }) {
     const fullTableName = this.getTableName(TABLE_THREADS);
     try {
@@ -556,12 +664,66 @@ var D1Store = class extends MastraStorage {
         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)
-      });
+      const mastraError = new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_THREADS_BY_RESOURCE_ID_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Error getting threads by resourceId ${resourceId}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { resourceId }
+        },
+        error
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return [];
     }
   }
+  async getThreadsByResourceIdPaginated(args) {
+    const { resourceId, page, perPage } = args;
+    const fullTableName = this.getTableName(TABLE_THREADS);
+    const mapRowToStorageThreadType = (row) => ({
+      ...row,
+      createdAt: this.ensureDate(row.createdAt),
+      updatedAt: this.ensureDate(row.updatedAt),
+      metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata || "{}") : row.metadata || {}
+    });
+    try {
+      const countQuery = createSqlBuilder().count().from(fullTableName).where("resourceId = ?", resourceId);
+      const countResult = await this.executeQuery(countQuery.build());
+      const total = Number(countResult?.[0]?.count ?? 0);
+      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("resourceId = ?", resourceId).orderBy("createdAt", "DESC").limit(perPage).offset(page * perPage);
+      const results = await this.executeQuery(selectQuery.build());
+      const threads = results.map(mapRowToStorageThreadType);
+      return {
+        threads,
+        total,
+        page,
+        perPage,
+        hasMore: page * perPage + threads.length < total
+      };
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Error getting threads by resourceId ${resourceId}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { resourceId }
+        },
+        error
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return {
+        threads: [],
+        total: 0,
+        page,
+        perPage,
+        hasMore: false
+      };
+    }
+  }
   async saveThread({ thread }) {
     const fullTableName = this.getTableName(TABLE_THREADS);
     const threadToSave = {
@@ -588,8 +750,16 @@ var D1Store = class extends MastraStorage {
       await this.executeQuery({ sql, params });
       return thread;
     } catch (error) {
-      this.logger.error(`Error saving thread to ${fullTableName}:`, { error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_SAVE_THREAD_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to save thread to ${fullTableName}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { threadId: thread.id }
+        },
+        error
+      );
     }
   }
   async updateThread({
@@ -598,19 +768,19 @@ var D1Store = class extends MastraStorage {
     metadata
   }) {
     const thread = await this.getThreadById({ threadId: id });
-    if (!thread) {
-      throw new Error(`Thread ${id} not found`);
-    }
-    const fullTableName = this.getTableName(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 {
+      if (!thread) {
+        throw new Error(`Thread ${id} not found`);
+      }
+      const fullTableName = this.getTableName(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();
       await this.executeQuery({ sql, params });
       return {
         ...thread,
@@ -622,8 +792,16 @@ var D1Store = class extends MastraStorage {
         updatedAt: /* @__PURE__ */ new Date()
       };
     } catch (error) {
-      this.logger.error("Error updating thread:", { error });
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_UPDATE_THREAD_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to update thread ${id}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { threadId: id }
+        },
+        error
+      );
     }
   }
   async deleteThread({ threadId }) {
@@ -637,17 +815,24 @@ var D1Store = class extends MastraStorage {
       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}`);
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_DELETE_THREAD_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to delete thread ${threadId}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { threadId }
+        },
+        error
+      );
     }
   }
-  // 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`);
@@ -666,36 +851,49 @@ var D1Store = class extends 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: TABLE_MESSAGES,
-        records: messagesToInsert
-      });
+      await Promise.all([
+        this.batchUpsert({
+          tableName: TABLE_MESSAGES,
+          records: messagesToInsert
+        }),
+        // Update thread's updatedAt timestamp
+        this.executeQuery({
+          sql: `UPDATE ${this.getTableName(TABLE_THREADS)} SET updatedAt = ? WHERE id = ?`,
+          params: [now.toISOString(), threadId]
+        })
+      ]);
       this.logger.debug(`Saved ${messages.length} messages`);
-      return messages;
+      const list = new MessageList().add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
-      this.logger.error("Error saving messages:", { message: error instanceof Error ? error.message : String(error) });
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_SAVE_MESSAGES_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to save messages: ${error instanceof Error ? error.message : String(error)}`
+        },
+        error
+      );
     }
   }
-  async getMessages({ threadId, selectBy }) {
-    const fullTableName = this.getTableName(TABLE_MESSAGES);
-    const limit = typeof selectBy?.last === "number" ? selectBy.last : 40;
-    const include = selectBy?.include || [];
-    const messages = [];
-    try {
-      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 = `
+  async _getIncludedMessages(threadId, selectBy) {
+    const include = selectBy?.include;
+    if (!include) return null;
+    const prevMax = Math.max(...include.map((i) => i.withPreviousMessages || 0));
+    const nextMax = Math.max(...include.map((i) => i.withNextMessages || 0));
+    const includeIds = include.map((i) => i.id);
+    const sql = `
         WITH ordered_messages AS (
           SELECT
             *,
             ROW_NUMBER() OVER (ORDER BY createdAt DESC) AS row_num
-          FROM ${fullTableName}
+          FROM ${this.getTableName(TABLE_MESSAGES)}
           WHERE thread_id = ?
         )
         SELECT
@@ -704,7 +902,7 @@ var D1Store = class extends MastraStorage {
           m.role,
           m.type,
           m.createdAt,
-          m.thread_id AS "threadId"
+          m.thread_id AS threadId
         FROM ordered_messages m
         WHERE m.id IN (${includeIds.map(() => "?").join(",")})
         OR EXISTS (
@@ -718,20 +916,38 @@ var D1Store = class extends MastraStorage {
         )
         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 params = [
+      threadId,
+      ...includeIds,
+      // for m.id IN (...)
+      ...includeIds,
+      // for target.id IN (...)
+      prevMax,
+      nextMax
+    ];
+    const messages = await this.executeQuery({ sql, params });
+    return messages;
+  }
+  async getMessages({
+    threadId,
+    selectBy,
+    format
+  }) {
+    const fullTableName = this.getTableName(TABLE_MESSAGES);
+    const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
+    const include = selectBy?.include || [];
+    const messages = [];
+    try {
+      if (include.length) {
+        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 });
       if (Array.isArray(result)) messages.push(...result);
@@ -745,18 +961,92 @@ var D1Store = class extends MastraStorage {
       const processedMessages = messages.map((message) => {
         const processedMsg = {};
         for (const [key, value] of Object.entries(message)) {
+          if (key === `type` && value === `v2`) continue;
           processedMsg[key] = this.deserializeValue(value);
         }
         return processedMsg;
       });
       this.logger.debug(`Retrieved ${messages.length} messages for thread ${threadId}`);
-      return processedMessages;
+      const list = new MessageList().add(processedMessages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
-      this.logger.error("Error retrieving messages for thread", {
-        threadId,
-        message: error instanceof Error ? error.message : String(error)
-      });
-      return [];
+      const mastraError = new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_MESSAGES_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to retrieve messages for thread ${threadId}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { threadId }
+        },
+        error
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      throw mastraError;
+    }
+  }
+  async getMessagesPaginated({
+    threadId,
+    selectBy,
+    format
+  }) {
+    const { dateRange, page = 0, perPage = 40 } = selectBy?.pagination || {};
+    const { start: fromDate, end: toDate } = dateRange || {};
+    const fullTableName = this.getTableName(TABLE_MESSAGES);
+    const messages = [];
+    try {
+      if (selectBy?.include?.length) {
+        const includeResult = await this._getIncludedMessages(threadId, selectBy);
+        if (Array.isArray(includeResult)) messages.push(...includeResult);
+      }
+      const countQuery = createSqlBuilder().count().from(fullTableName).where("thread_id = ?", threadId);
+      if (fromDate) {
+        countQuery.andWhere("createdAt >= ?", this.serializeDate(fromDate));
+      }
+      if (toDate) {
+        countQuery.andWhere("createdAt <= ?", this.serializeDate(toDate));
+      }
+      const countResult = await this.executeQuery(countQuery.build());
+      const total = Number(countResult[0]?.count ?? 0);
+      const query = createSqlBuilder().select(["id", "content", "role", "type", "createdAt", "thread_id AS threadId"]).from(fullTableName).where("thread_id = ?", threadId);
+      if (fromDate) {
+        query.andWhere("createdAt >= ?", this.serializeDate(fromDate));
+      }
+      if (toDate) {
+        query.andWhere("createdAt <= ?", this.serializeDate(toDate));
+      }
+      query.orderBy("createdAt", "DESC").limit(perPage).offset(page * perPage);
+      const results = await this.executeQuery(query.build());
+      const list = new MessageList().add(results, "memory");
+      messages.push(...format === `v2` ? list.get.all.v2() : list.get.all.v1());
+      return {
+        messages,
+        total,
+        page,
+        perPage,
+        hasMore: page * perPage + messages.length < total
+      };
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_MESSAGES_PAGINATED_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to retrieve messages for thread ${threadId}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { threadId }
+        },
+        error
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage,
+        hasMore: false
+      };
     }
   }
   async persistWorkflowSnapshot({
@@ -794,23 +1084,42 @@ var D1Store = class extends MastraStorage {
     try {
       await this.executeQuery({ sql, params });
     } catch (error) {
-      this.logger.error("Error persisting workflow snapshot:", {
-        message: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_PERSIST_WORKFLOW_SNAPSHOT_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to persist workflow snapshot: ${error instanceof Error ? error.message : String(error)}`,
+          details: { workflowName, runId }
+        },
+        error
+      );
     }
   }
   async loadWorkflowSnapshot(params) {
     const { workflowName, runId } = params;
     this.logger.debug("Loading workflow snapshot", { workflowName, runId });
-    const d = await this.load({
-      tableName: TABLE_WORKFLOW_SNAPSHOT,
-      keys: {
-        workflow_name: workflowName,
-        run_id: runId
-      }
-    });
-    return d ? d.snapshot : null;
+    try {
+      const d = await this.load({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        keys: {
+          workflow_name: workflowName,
+          run_id: runId
+        }
+      });
+      return d ? d.snapshot : null;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_LOAD_WORKFLOW_SNAPSHOT_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to load workflow snapshot: ${error instanceof Error ? error.message : String(error)}`,
+          details: { workflowName, runId }
+        },
+        error
+      );
+    }
   }
   /**
    * Insert multiple records in a batch operation
@@ -845,18 +1154,84 @@ var D1Store = class extends MastraStorage {
       }
       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)
-      });
-      throw new Error(`Failed to batch insert into ${tableName}: ${error}`);
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_BATCH_INSERT_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to batch insert into ${tableName}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
+  /**
+   * Upsert multiple records in a batch operation
+   * @param tableName The table to insert into
+   * @param records The records to insert
+   */
+  async batchUpsert({
+    tableName,
+    records
+  }) {
+    if (records.length === 0) return;
+    const fullTableName = this.getTableName(tableName);
+    try {
+      const batchSize = 50;
+      for (let i = 0; i < records.length; i += batchSize) {
+        const batch = records.slice(i, i + batchSize);
+        const recordsToInsert = batch;
+        if (recordsToInsert.length > 0) {
+          const firstRecord = recordsToInsert[0];
+          const columns = Object.keys(firstRecord || {});
+          for (const record of recordsToInsert) {
+            const values = columns.map((col) => {
+              if (!record) return null;
+              const value = typeof col === "string" ? record[col] : null;
+              return this.serializeValue(value);
+            });
+            const recordToUpsert = columns.reduce(
+              (acc, col) => {
+                if (col !== "createdAt") acc[col] = `excluded.${col}`;
+                return acc;
+              },
+              {}
+            );
+            const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], recordToUpsert);
+            const { sql, params } = query.build();
+            await this.executeQuery({ sql, params });
+          }
+        }
+        this.logger.debug(
+          `Processed batch ${Math.floor(i / batchSize) + 1} of ${Math.ceil(records.length / batchSize)}`
+        );
+      }
+      this.logger.debug(`Successfully batch upserted ${records.length} records into ${tableName}`);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_BATCH_UPSERT_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to batch upsert into ${tableName}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  /**
+   * @deprecated use getTracesPaginated instead
+   */
   async getTraces({
     name,
     scope,
     page,
     perPage,
-    attributes
+    attributes,
+    fromDate,
+    toDate
   }) {
     const fullTableName = this.getTableName(TABLE_TRACES);
     try {
@@ -872,22 +1247,114 @@ var D1Store = class extends MastraStorage {
           query.jsonLike("attributes", key, value);
         }
       }
-      query.orderBy("startTime", "DESC").limit(perPage).offset((page - 1) * perPage);
+      if (fromDate) {
+        query.andWhere("createdAt >= ?", fromDate instanceof Date ? fromDate.toISOString() : fromDate);
+      }
+      if (toDate) {
+        query.andWhere("createdAt <= ?", toDate instanceof Date ? toDate.toISOString() : toDate);
+      }
+      query.orderBy("startTime", "DESC").limit(perPage).offset(page * perPage);
       const { sql, params } = query.build();
       const results = await this.executeQuery({ sql, params });
-      return isArrayOfRecords(results) ? results.map((trace) => ({
-        ...trace,
-        attributes: this.deserializeValue(trace.attributes, "jsonb"),
-        status: this.deserializeValue(trace.status, "jsonb"),
-        events: this.deserializeValue(trace.events, "jsonb"),
-        links: this.deserializeValue(trace.links, "jsonb"),
-        other: this.deserializeValue(trace.other, "jsonb")
-      })) : [];
+      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) });
+      const mastraError = new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_TRACES_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to retrieve traces: ${error instanceof Error ? error.message : String(error)}`,
+          details: {
+            name: name ?? "",
+            scope: scope ?? ""
+          }
+        },
+        error
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return [];
     }
   }
+  async getTracesPaginated(args) {
+    const { name, scope, page, perPage, attributes, fromDate, toDate } = args;
+    const fullTableName = this.getTableName(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 countResult = await this.executeQuery(countQuery.build());
+      const total = Number(countResult?.[0]?.count ?? 0);
+      dataQuery.orderBy("startTime", "DESC").limit(perPage).offset(page * perPage);
+      const results = await this.executeQuery(dataQuery.build());
+      const traces = isArrayOfRecords(results) ? results.map(
+        (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")
+        })
+      ) : [];
+      return {
+        traces,
+        total,
+        page,
+        perPage,
+        hasMore: page * perPage + traces.length < total
+      };
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_TRACES_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to retrieve traces: ${error instanceof Error ? error.message : String(error)}`,
+          details: { name: name ?? "", scope: scope ?? "" }
+        },
+        error
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return { traces: [], total: 0, page, perPage, hasMore: false };
+    }
+  }
+  /**
+   * @deprecated use getEvals instead
+   */
   async getEvalsByAgentName(agentName, type) {
     const fullTableName = this.getTableName(TABLE_EVALS);
     try {
@@ -917,14 +1384,221 @@ var D1Store = class extends MastraStorage {
         };
       }) : [];
     } catch (error) {
-      this.logger.error(`Error getting evals for agent ${agentName}:`, {
-        message: error instanceof Error ? error.message : String(error)
-      });
+      const mastraError = new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_EVALS_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to retrieve evals for agent ${agentName}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { agentName }
+        },
+        error
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
       return [];
     }
   }
-  getWorkflowRuns(_args) {
-    throw new Error("Method not implemented.");
+  async getEvals(options) {
+    const { agentName, type, page = 0, perPage = 40, fromDate, toDate } = options || {};
+    const fullTableName = this.getTableName(TABLE_EVALS);
+    const conditions = [];
+    const queryParams = [];
+    if (agentName) {
+      conditions.push(`agent_name = ?`);
+      queryParams.push(agentName);
+    }
+    if (type === "test") {
+      conditions.push(`(test_info IS NOT NULL AND json_extract(test_info, '$.testPath') IS NOT NULL)`);
+    } else if (type === "live") {
+      conditions.push(`(test_info IS NULL OR json_extract(test_info, '$.testPath') IS NULL)`);
+    }
+    if (fromDate) {
+      conditions.push(`createdAt >= ?`);
+      queryParams.push(this.serializeDate(fromDate));
+    }
+    if (toDate) {
+      conditions.push(`createdAt <= ?`);
+      queryParams.push(this.serializeDate(toDate));
+    }
+    const countQueryBuilder = createSqlBuilder().count().from(fullTableName);
+    if (conditions.length > 0) {
+      countQueryBuilder.where(conditions.join(" AND "), ...queryParams);
+    }
+    const { sql: countSql, params: countParams } = countQueryBuilder.build();
+    try {
+      const countResult = await this.executeQuery({ sql: countSql, params: countParams, first: true });
+      const total = Number(countResult?.count || 0);
+      const currentOffset = page * perPage;
+      if (total === 0) {
+        return {
+          evals: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const dataQueryBuilder = createSqlBuilder().select("*").from(fullTableName);
+      if (conditions.length > 0) {
+        dataQueryBuilder.where(conditions.join(" AND "), ...queryParams);
+      }
+      dataQueryBuilder.orderBy("createdAt", "DESC").limit(perPage).offset(currentOffset);
+      const { sql: dataSql, params: dataParams } = dataQueryBuilder.build();
+      const rows = await this.executeQuery({ sql: dataSql, params: dataParams });
+      const evals = (isArrayOfRecords(rows) ? rows : []).map((row) => {
+        const result = this.deserializeValue(row.result);
+        const testInfo = row.test_info ? this.deserializeValue(row.test_info) : void 0;
+        if (!result || typeof result !== "object" || !("score" in result)) {
+          throw new Error(`Invalid MetricResult format: ${JSON.stringify(result)}`);
+        }
+        return {
+          input: row.input,
+          output: row.output,
+          result,
+          agentName: row.agent_name,
+          metricName: row.metric_name,
+          instructions: row.instructions,
+          testInfo,
+          globalRunId: row.global_run_id,
+          runId: row.run_id,
+          createdAt: row.createdAt
+        };
+      });
+      const hasMore = currentOffset + evals.length < total;
+      return {
+        evals,
+        total,
+        page,
+        perPage,
+        hasMore
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_EVALS_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to retrieve evals for agent ${agentName}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { agentName: agentName ?? "", type: type ?? "" }
+        },
+        error
+      );
+    }
+  }
+  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: this.ensureDate(row.createdAt),
+      updatedAt: this.ensureDate(row.updatedAt),
+      resourceId: row.resourceId
+    };
+  }
+  async hasColumn(table, column) {
+    const sql = `PRAGMA table_info(${table});`;
+    const result = await this.executeQuery({ sql, params: [] });
+    if (!result || !Array.isArray(result)) return false;
+    return result.some((col) => col.name === column || col.name === column.toLowerCase());
+  }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset,
+    resourceId
+  } = {}) {
+    const fullTableName = this.getTableName(TABLE_WORKFLOW_SNAPSHOT);
+    try {
+      const builder = createSqlBuilder().select().from(fullTableName);
+      const countBuilder = createSqlBuilder().count().from(fullTableName);
+      if (workflowName) builder.whereAnd("workflow_name = ?", workflowName);
+      if (resourceId) {
+        const hasResourceId = await this.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.executeQuery({ sql: countSql, params: countParams, first: true });
+        total = Number(countResult?.count ?? 0);
+      }
+      const results = await this.executeQuery({ sql, params });
+      const runs = (isArrayOfRecords(results) ? results : []).map((row) => this.parseWorkflowRun(row));
+      return { runs, total: total || runs.length };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_WORKFLOW_RUNS_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to retrieve workflow runs: ${error instanceof Error ? error.message : String(error)}`,
+          details: { workflowName: workflowName ?? "", resourceId: resourceId ?? "" }
+        },
+        error
+      );
+    }
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    const fullTableName = this.getTableName(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.executeQuery({ sql, params, first: true });
+      if (!result) return null;
+      return this.parseWorkflowRun(result);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLOUDFLARE_D1_STORAGE_GET_WORKFLOW_RUN_BY_ID_ERROR",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to retrieve workflow run by ID: ${error instanceof Error ? error.message : String(error)}`,
+          details: { runId, workflowName: workflowName ?? "" }
+        },
+        error
+      );
+    }
   }
   /**
    * Close the database connection
@@ -933,6 +1607,10 @@ var D1Store = class extends MastraStorage {
   async close() {
     this.logger.debug("Closing D1 connection");
   }
+  async updateMessages(_args) {
+    this.logger.error("updateMessages is not yet implemented in CloudflareD1Store");
+    throw new Error("Method not implemented");
+  }
 };
 
 export { D1Store };