@mastra/cloudflare 1.2.3 → 1.3.0

package/dist/chunk-NSFHQATX.js

@@ -0,0 +1,2128 @@
+import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
+import { createStorageErrorId, getSqlType, getDefaultValue, MemoryStorage, TABLE_SCHEMAS, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, ensureDate, normalizePerPage, calculatePagination, serializeDate, ScoresStorage, TABLE_SCORERS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, MastraCompositeStore, transformScoreRow as transformScoreRow$1 } from '@mastra/core/storage';
+import { MessageList } from '@mastra/core/agent';
+import { MastraBase } from '@mastra/core/base';
+import { parseSqlIdentifier } from '@mastra/core/utils';
+import { saveScorePayloadSchema } from '@mastra/core/evals';
+
+// src/do/index.ts
+
+// src/do/storage/domains/utils.ts
+function isArrayOfRecords(value) {
+  return value !== null && value !== void 0 && Array.isArray(value);
+}
+function deserializeValue(value, type) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+var SqlBuilder = class {
+  sql = "";
+  params = [];
+  whereAdded = false;
+  // Basic query building
+  select(columns) {
+    if (!columns || Array.isArray(columns) && columns.length === 0) {
+      this.sql = "SELECT *";
+    } else {
+      const cols = Array.isArray(columns) ? columns : [columns];
+      const parsedCols = cols.map((col) => parseSelectIdentifier(col));
+      this.sql = `SELECT ${parsedCols.join(", ")}`;
+    }
+    return this;
+  }
+  from(table) {
+    const parsedTableName = parseSqlIdentifier(table, "table name");
+    this.sql += ` FROM ${parsedTableName}`;
+    return this;
+  }
+  /**
+   * Add a WHERE clause to the query
+   * @param condition The condition to add
+   * @param params Parameters to bind to the condition
+   */
+  where(condition, ...params) {
+    this.sql += ` WHERE ${condition}`;
+    this.params.push(...params);
+    this.whereAdded = true;
+    return this;
+  }
+  /**
+   * Add a WHERE clause if it hasn't been added yet, otherwise add an AND clause
+   * @param condition The condition to add
+   * @param params Parameters to bind to the condition
+   */
+  whereAnd(condition, ...params) {
+    if (this.whereAdded) {
+      return this.andWhere(condition, ...params);
+    } else {
+      return this.where(condition, ...params);
+    }
+  }
+  andWhere(condition, ...params) {
+    this.sql += ` AND ${condition}`;
+    this.params.push(...params);
+    return this;
+  }
+  orWhere(condition, ...params) {
+    this.sql += ` OR ${condition}`;
+    this.params.push(...params);
+    return this;
+  }
+  orderBy(column, direction = "ASC") {
+    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) {
+    this.sql += ` LIMIT ?`;
+    this.params.push(count);
+    return this;
+  }
+  offset(count) {
+    this.sql += ` OFFSET ?`;
+    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
+   * @param columns Columns to insert
+   * @param values Values to insert
+   * @param conflictColumns Columns to check for conflict (usually PK or UNIQUE)
+   * @param updateMap Object mapping columns to update to their new value (e.g. { name: 'excluded.name' })
+   */
+  insert(table, columns, values, conflictColumns, updateMap) {
+    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 excludedPattern = /^excluded\.[a-zA-Z_][a-zA-Z0-9_]*$/;
+      const coalescePattern = /^COALESCE\(excluded\.[a-zA-Z_][a-zA-Z0-9_]*,\s*[a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*\)$/;
+      const updateClause = Object.entries(updateMap).map(([col, expr]) => {
+        const parsedCol = parseSqlIdentifier(col, "update column name");
+        if (!excludedPattern.test(expr) && !coalescePattern.test(expr)) {
+          throw new Error(
+            `Invalid update expression for column ${col}: must be 'excluded.<column>' or 'COALESCE(excluded.<column>, <table>.<column>)' pattern`
+          );
+        }
+        return `${parsedCol} = ${expr}`;
+      }).join(", ");
+      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 ${parsedTableName} (${parsedColumns.join(", ")}) VALUES (${placeholders})`;
+    this.params.push(...values);
+    return this;
+  }
+  // Update operations
+  update(table, columns, values) {
+    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) {
+    const parsedTableName = parseSqlIdentifier(table, "table name");
+    this.sql = `DELETE FROM ${parsedTableName}`;
+    return this;
+  }
+  /**
+   * Create a table if it doesn't exist
+   * @param table The table name
+   * @param columnDefinitions The column definitions as an array of strings
+   * @param tableConstraints Optional constraints for the table
+   * @returns The builder instance
+   */
+  createTable(table, columnDefinitions, tableConstraints) {
+    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(", ");
+    let constraints = "";
+    if (tableConstraints && tableConstraints.length > 0) {
+      const constraintPattern = /^(PRIMARY\s+KEY|UNIQUE|FOREIGN\s+KEY|CHECK)\s*\([a-zA-Z0-9_,\s]+\)$/i;
+      for (const constraint of tableConstraints) {
+        if (!constraintPattern.test(constraint.trim())) {
+          throw new Error(`Invalid table constraint: ${constraint}`);
+        }
+      }
+      constraints = ", " + tableConstraints.join(", ");
+    }
+    this.sql = `CREATE TABLE IF NOT EXISTS ${parsedTableName} (${columns}${constraints})`;
+    return this;
+  }
+  /**
+   * Check if an index exists in the database
+   * @param indexName The name of the index to check
+   * @param tableName The table the index is on
+   * @returns The builder instance
+   */
+  checkIndexExists(indexName, tableName) {
+    this.sql = `SELECT name FROM sqlite_master WHERE type='index' AND name=? AND tbl_name=?`;
+    this.params.push(indexName, tableName);
+    return this;
+  }
+  /**
+   * Create an index if it doesn't exist
+   * @param indexName The name of the index to create
+   * @param tableName The table to create the index on
+   * @param columnName The column to index
+   * @param indexType Optional index type (e.g., 'UNIQUE')
+   * @returns The builder instance
+   */
+  createIndex(indexName, tableName, columnName, indexType = "") {
+    const parsedIndexName = parseSqlIdentifier(indexName, "index name");
+    const parsedTableName = parseSqlIdentifier(tableName, "table name");
+    const parsedColumnName = parseSqlIdentifier(columnName, "column name");
+    const allowedIndexTypes = ["", "UNIQUE"];
+    const normalizedIndexType = indexType.toUpperCase().trim();
+    if (!allowedIndexTypes.includes(normalizedIndexType)) {
+      throw new Error(
+        `Invalid index type: ${indexType}. Allowed values: ${allowedIndexTypes.filter((t) => t).join(", ")}`
+      );
+    }
+    this.sql = `CREATE ${normalizedIndexType ? normalizedIndexType + " " : ""}INDEX IF NOT EXISTS ${parsedIndexName} ON ${parsedTableName}(${parsedColumnName})`;
+    return this;
+  }
+  /**
+   * Add a LIKE condition to the query
+   * @param column The column to check
+   * @param value The value to match (will be wrapped with % for LIKE)
+   * @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 ${parsedColumnName} LIKE ?`;
+    } else {
+      this.sql += ` WHERE ${parsedColumnName} LIKE ?`;
+      this.whereAdded = true;
+    }
+    this.params.push(likeValue);
+    return this;
+  }
+  /**
+   * Add a JSON LIKE condition for searching in JSON fields
+   * @param column The JSON column to search in
+   * @param key The JSON key to match
+   * @param value The value to match
+   */
+  jsonLike(column, key, value) {
+    const parsedColumnName = parseSqlIdentifier(column, "column name");
+    const parsedKey = parseSqlIdentifier(key, "key name");
+    const jsonPattern = `%"${parsedKey}":"${value}"%`;
+    if (this.whereAdded) {
+      this.sql += ` AND ${parsedColumnName} LIKE ?`;
+    } else {
+      this.sql += ` WHERE ${parsedColumnName} LIKE ?`;
+      this.whereAdded = true;
+    }
+    this.params.push(jsonPattern);
+    return this;
+  }
+  /**
+   * Get the built query
+   * @returns Object containing the SQL string and parameters array
+   */
+  build() {
+    return {
+      sql: this.sql,
+      params: this.params
+    };
+  }
+  /**
+   * Reset the builder for reuse
+   * @returns The reset builder instance
+   */
+  reset() {
+    this.sql = "";
+    this.params = [];
+    this.whereAdded = false;
+    return this;
+  }
+};
+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/do/storage/db/index.ts
+var DODB = class extends MastraBase {
+  sql;
+  tablePrefix;
+  constructor(config) {
+    super({
+      component: "STORAGE",
+      name: "DO_DB"
+    });
+    this.sql = config.sql;
+    this.tablePrefix = config.tablePrefix || "";
+  }
+  async hasColumn(table, column) {
+    const identifierPattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
+    if (!identifierPattern.test(table)) {
+      throw new Error(`Invalid table name: ${table}`);
+    }
+    if (!identifierPattern.test(column)) {
+      throw new Error(`Invalid column name: ${column}`);
+    }
+    if (this.tablePrefix && !identifierPattern.test(this.tablePrefix)) {
+      throw new Error(`Invalid table prefix: ${this.tablePrefix}`);
+    }
+    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);
+  }
+  /**
+   * Execute a SQL query using Durable Objects SqlStorage.
+   * SqlStorage.exec() is synchronous but we wrap in Promise for interface compatibility.
+   */
+  async executeQuery(options) {
+    const { sql, params = [], first = false } = options;
+    try {
+      const formattedParams = this.formatSqlParams(params);
+      const cursor = this.sql.exec(sql, ...formattedParams);
+      if (first) {
+        const rows = cursor.toArray();
+        return rows[0] || null;
+      }
+      return cursor.toArray();
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "QUERY", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { sql }
+        },
+        error
+      );
+    }
+  }
+  async getTableColumns(tableName) {
+    const identifierPattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
+    if (!identifierPattern.test(tableName)) {
+      this.logger.warn(`Invalid table name in getTableColumns: ${tableName}`);
+      return [];
+    }
+    try {
+      const sql = `PRAGMA table_info(${tableName})`;
+      const result = await this.executeQuery({ sql });
+      if (!result || !Array.isArray(result)) {
+        return [];
+      }
+      return result.map((row) => ({
+        name: row.name,
+        type: row.type
+      }));
+    } catch (error) {
+      this.logger.warn(`Failed to get table columns for ${tableName}:`, error);
+      return [];
+    }
+  }
+  serializeValue(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return value;
+  }
+  getSqlType(type) {
+    switch (type) {
+      case "bigint":
+        return "INTEGER";
+      // SQLite uses INTEGER for all integer sizes
+      case "jsonb":
+        return "TEXT";
+      // Store JSON as TEXT in SQLite
+      case "boolean":
+        return "INTEGER";
+      // SQLite uses 0/1 for booleans
+      default:
+        return getSqlType(type);
+    }
+  }
+  getDefaultValue(type) {
+    return getDefaultValue(type);
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    try {
+      const fullTableName = this.getTableName(tableName);
+      const columnDefinitions = Object.entries(schema).map(([colName, colDef]) => {
+        const type = this.getSqlType(colDef.type);
+        const nullable = colDef.nullable === false ? "NOT NULL" : "";
+        const primaryKey = colDef.primaryKey ? "PRIMARY KEY" : "";
+        return `${colName} ${type} ${nullable} ${primaryKey}`.trim();
+      });
+      const tableConstraints = [];
+      if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
+        tableConstraints.push("UNIQUE (workflow_name, run_id)");
+      }
+      const query = createSqlBuilder().createTable(fullTableName, columnDefinitions, tableConstraints);
+      const { sql, params } = query.build();
+      await this.executeQuery({ sql, params });
+      this.logger.debug(`Created table ${fullTableName}`);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "CREATE_TABLE", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  async clearTable({ tableName }) {
+    try {
+      const fullTableName = this.getTableName(tableName);
+      const query = createSqlBuilder().delete(fullTableName);
+      const { sql, params } = query.build();
+      await this.executeQuery({ sql, params });
+      this.logger.debug(`Cleared table ${fullTableName}`);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "CLEAR_TABLE", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  async dropTable({ tableName }) {
+    try {
+      const fullTableName = this.getTableName(tableName);
+      const sql = `DROP TABLE IF EXISTS ${fullTableName}`;
+      await this.executeQuery({ sql });
+      this.logger.debug(`Dropped table ${fullTableName}`);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "DROP_TABLE", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  async alterTable(args) {
+    const identifierPattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
+    try {
+      const fullTableName = this.getTableName(args.tableName);
+      if (!identifierPattern.test(fullTableName)) {
+        throw new Error(`Invalid table name: ${fullTableName}`);
+      }
+      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 (!identifierPattern.test(columnName)) {
+          throw new Error(`Invalid column name: ${columnName}`);
+        }
+        if (!existingColumnNames.has(columnName) && args.ifNotExists.includes(columnName)) {
+          const sqlType = this.getSqlType(column.type);
+          const defaultValue = this.getDefaultValue(column.type);
+          const sql = `ALTER TABLE ${fullTableName} ADD COLUMN ${columnName} ${sqlType} ${defaultValue}`;
+          await this.executeQuery({ sql });
+          this.logger.debug(`Added column ${columnName} to table ${fullTableName}`);
+        }
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "ALTER_TABLE", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName: args.tableName }
+        },
+        error
+      );
+    }
+  }
+  async insert({ tableName, record }) {
+    try {
+      const fullTableName = this.getTableName(tableName);
+      const processedRecord = await this.processRecord(record);
+      const columns = Object.keys(processedRecord);
+      const values = Object.values(processedRecord);
+      const query = createSqlBuilder().insert(fullTableName, columns, values);
+      const { sql, params } = query.build();
+      await this.executeQuery({ sql, params });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "INSERT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  async batchInsert({
+    tableName,
+    records
+  }) {
+    try {
+      if (records.length === 0) return;
+      const fullTableName = this.getTableName(tableName);
+      const processedRecords = await Promise.all(records.map((record) => this.processRecord(record)));
+      const columns = Object.keys(processedRecords[0] || {});
+      for (const record of processedRecords) {
+        const values = Object.values(record);
+        const query = createSqlBuilder().insert(fullTableName, columns, values);
+        const { sql, params } = query.build();
+        await this.executeQuery({ sql, params });
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "BATCH_INSERT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  async load({
+    tableName,
+    keys,
+    orderBy
+  }) {
+    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);
+        }
+      }
+      if (orderBy) {
+        query.orderBy(orderBy.column, orderBy.direction);
+      }
+      query.limit(1);
+      const { sql, params } = query.build();
+      const result = await this.executeQuery({ sql, params, first: true });
+      if (!result) {
+        return null;
+      }
+      const deserializedResult = {};
+      for (const [key, value] of Object.entries(result)) {
+        deserializedResult[key] = deserializeValue(value);
+      }
+      return deserializedResult;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "LOAD", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  async processRecord(record) {
+    const processed = {};
+    for (const [key, value] of Object.entries(record)) {
+      processed[key] = this.serializeValue(value);
+    }
+    return processed;
+  }
+  /**
+   * Upsert multiple records in a batch operation
+   * @param tableName The table to insert into
+   * @param records The records to insert
+   * @param conflictKeys The columns to use for conflict detection (defaults to ['id'])
+   */
+  async batchUpsert({
+    tableName,
+    records,
+    conflictKeys = ["id"]
+  }) {
+    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" && !conflictKeys.includes(col)) {
+                  acc[col] = `excluded.${col}`;
+                }
+                return acc;
+              },
+              {}
+            );
+            const query = createSqlBuilder().insert(
+              fullTableName,
+              columns,
+              values,
+              conflictKeys,
+              recordToUpsert
+            );
+            const { sql, params } = query.build();
+            await this.executeQuery({ sql, params });
+          }
+        }
+        this.logger.debug(
+          `Processed batch ${Math.floor(i / batchSize) + 1} of ${Math.ceil(records.length / batchSize)}`
+        );
+      }
+      this.logger.debug(`Successfully batch upserted ${records.length} records into ${tableName}`);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "BATCH_UPSERT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to batch upsert into ${tableName}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+};
+
+// src/do/storage/domains/memory/index.ts
+var MemoryStorageDO = class extends MemoryStorage {
+  #db;
+  constructor(config) {
+    super();
+    this.#db = new DODB(config);
+  }
+  async init() {
+    await this.#db.createTable({ tableName: TABLE_THREADS, schema: TABLE_SCHEMAS[TABLE_THREADS] });
+    await this.#db.createTable({ tableName: TABLE_MESSAGES, schema: TABLE_SCHEMAS[TABLE_MESSAGES] });
+    await this.#db.createTable({ tableName: TABLE_RESOURCES, schema: TABLE_SCHEMAS[TABLE_RESOURCES] });
+    await this.#db.alterTable({
+      tableName: TABLE_MESSAGES,
+      schema: TABLE_SCHEMAS[TABLE_MESSAGES],
+      ifNotExists: ["resourceId"]
+    });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: TABLE_MESSAGES });
+    await this.#db.clearTable({ tableName: TABLE_THREADS });
+    await this.#db.clearTable({ tableName: TABLE_RESOURCES });
+  }
+  async getResourceById({ resourceId }) {
+    const resource = await this.#db.load({
+      tableName: TABLE_RESOURCES,
+      keys: { id: resourceId }
+    });
+    if (!resource) return null;
+    try {
+      return {
+        ...resource,
+        createdAt: ensureDate(resource.createdAt),
+        updatedAt: ensureDate(resource.updatedAt),
+        metadata: typeof resource.metadata === "string" ? JSON.parse(resource.metadata || "{}") : resource.metadata
+      };
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "GET_RESOURCE_BY_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Error processing resource ${resourceId}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { resourceId }
+        },
+        error
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return null;
+    }
+  }
+  async saveResource({ resource }) {
+    const fullTableName = this.#db.getTableName(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.#db.processRecord(resourceToSave);
+    const columns = Object.keys(processedRecord);
+    const values = Object.values(processedRecord);
+    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.#db.executeQuery({ sql, params });
+      return resource;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "SAVE_RESOURCE", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to save resource to ${fullTableName}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { resourceId: resource.id }
+        },
+        error
+      );
+    }
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    const existingResource = await this.getResourceById({ resourceId });
+    if (!existingResource) {
+      const newResource = {
+        id: resourceId,
+        workingMemory,
+        metadata: metadata || {},
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      return this.saveResource({ resource: newResource });
+    }
+    const updatedAt = /* @__PURE__ */ new Date();
+    const updatedResource = {
+      ...existingResource,
+      workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+      metadata: {
+        ...existingResource.metadata,
+        ...metadata
+      },
+      updatedAt
+    };
+    const fullTableName = this.#db.getTableName(TABLE_RESOURCES);
+    const columns = ["workingMemory", "metadata", "updatedAt"];
+    const values = [updatedResource.workingMemory, JSON.stringify(updatedResource.metadata), updatedAt.toISOString()];
+    const query = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", resourceId);
+    const { sql, params } = query.build();
+    try {
+      await this.#db.executeQuery({ sql, params });
+      return updatedResource;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "UPDATE_RESOURCE", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to update resource ${resourceId}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { resourceId }
+        },
+        error
+      );
+    }
+  }
+  async getThreadById({ threadId }) {
+    const thread = await this.#db.load({
+      tableName: TABLE_THREADS,
+      keys: { id: threadId }
+    });
+    if (!thread) return null;
+    try {
+      return {
+        ...thread,
+        createdAt: ensureDate(thread.createdAt),
+        updatedAt: ensureDate(thread.updatedAt),
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata || "{}") : thread.metadata || {}
+      };
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "GET_THREAD_BY_ID", "FAILED"),
+          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;
+    }
+  }
+  async listThreads(args) {
+    const { page = 0, perPage: perPageInput, orderBy, filter } = args;
+    try {
+      this.validatePaginationInput(page, perPageInput ?? 100);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "LIST_THREADS", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page, ...perPageInput !== void 0 && { perPage: perPageInput } }
+        },
+        error instanceof Error ? error : new Error("Invalid pagination parameters")
+      );
+    }
+    const perPage = normalizePerPage(perPageInput, 100);
+    try {
+      this.validateMetadataKeys(filter?.metadata);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "LIST_THREADS", "INVALID_METADATA_KEY"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { metadataKeys: filter?.metadata ? Object.keys(filter.metadata).join(", ") : "" }
+        },
+        error instanceof Error ? error : new Error("Invalid metadata key")
+      );
+    }
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    const { field, direction } = this.parseOrderBy(orderBy);
+    const fullTableName = this.#db.getTableName(TABLE_THREADS);
+    const mapRowToStorageThreadType = (row) => ({
+      ...row,
+      createdAt: ensureDate(row.createdAt),
+      updatedAt: ensureDate(row.updatedAt),
+      metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata || "{}") : row.metadata || {}
+    });
+    try {
+      let countQuery = createSqlBuilder().count().from(fullTableName);
+      let selectQuery = createSqlBuilder().select("*").from(fullTableName);
+      if (filter?.resourceId) {
+        countQuery = countQuery.whereAnd("resourceId = ?", filter.resourceId);
+        selectQuery = selectQuery.whereAnd("resourceId = ?", filter.resourceId);
+      }
+      if (filter?.metadata && Object.keys(filter.metadata).length > 0) {
+        for (const [key, value] of Object.entries(filter.metadata)) {
+          if (value !== null && typeof value === "object") {
+            throw new MastraError(
+              {
+                id: createStorageErrorId("CLOUDFLARE_DO", "LIST_THREADS", "INVALID_METADATA_VALUE"),
+                domain: ErrorDomain.STORAGE,
+                category: ErrorCategory.USER,
+                text: `Metadata filter value for key "${key}" must be a scalar type (string, number, boolean, or null), got ${Array.isArray(value) ? "array" : "object"}`,
+                details: { key, valueType: Array.isArray(value) ? "array" : "object" }
+              },
+              new Error("Invalid metadata filter value type")
+            );
+          }
+          if (value === null) {
+            const condition = `json_extract(metadata, '$.${key}') IS NULL`;
+            countQuery = countQuery.whereAnd(condition);
+            selectQuery = selectQuery.whereAnd(condition);
+          } else {
+            const condition = `json_extract(metadata, '$.${key}') = ?`;
+            const filterValue = value;
+            countQuery = countQuery.whereAnd(condition, filterValue);
+            selectQuery = selectQuery.whereAnd(condition, filterValue);
+          }
+        }
+      }
+      const countResult = await this.#db.executeQuery(countQuery.build());
+      const total = Number(countResult?.[0]?.count ?? 0);
+      if (total === 0) {
+        return {
+          threads: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      selectQuery = selectQuery.orderBy(field, direction).limit(limitValue).offset(offset);
+      const results = await this.#db.executeQuery(selectQuery.build());
+      const threads = results.map(mapRowToStorageThreadType);
+      return {
+        threads,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
+    } catch (error) {
+      if (error instanceof MastraError && error.category === ErrorCategory.USER) {
+        throw error;
+      }
+      const mastraError = new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "LIST_THREADS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Error listing threads: ${error instanceof Error ? error.message : String(error)}`,
+          details: {
+            ...filter?.resourceId && { resourceId: filter.resourceId },
+            hasMetadataFilter: !!filter?.metadata
+          }
+        },
+        error
+      );
+      this.logger?.error(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return {
+        threads: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
+    }
+  }
+  async saveThread({ thread }) {
+    const fullTableName = this.#db.getTableName(TABLE_THREADS);
+    const threadToSave = {
+      id: thread.id,
+      resourceId: thread.resourceId,
+      title: thread.title,
+      metadata: thread.metadata ? JSON.stringify(thread.metadata) : null,
+      createdAt: thread.createdAt.toISOString(),
+      updatedAt: thread.updatedAt.toISOString()
+    };
+    const processedRecord = await this.#db.processRecord(threadToSave);
+    const columns = Object.keys(processedRecord);
+    const values = Object.values(processedRecord);
+    const updateMap = {
+      resourceId: "excluded.resourceId",
+      title: "excluded.title",
+      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.#db.executeQuery({ sql, params });
+      return thread;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "SAVE_THREAD", "FAILED"),
+          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({
+    id,
+    title,
+    metadata
+  }) {
+    const thread = await this.getThreadById({ threadId: id });
+    try {
+      if (!thread) {
+        throw new Error(`Thread ${id} not found`);
+      }
+      const fullTableName = this.#db.getTableName(TABLE_THREADS);
+      const mergedMetadata = {
+        ...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.#db.executeQuery({ sql, params });
+      return {
+        ...thread,
+        title,
+        metadata: mergedMetadata,
+        updatedAt
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "UPDATE_THREAD", "FAILED"),
+          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 }) {
+    const fullTableName = this.#db.getTableName(TABLE_THREADS);
+    try {
+      const messagesTableName = this.#db.getTableName(TABLE_MESSAGES);
+      const deleteMessagesQuery = createSqlBuilder().delete(messagesTableName).where("thread_id = ?", threadId);
+      const { sql: messagesSql, params: messagesParams } = deleteMessagesQuery.build();
+      await this.#db.executeQuery({ sql: messagesSql, params: messagesParams });
+      const deleteThreadQuery = createSqlBuilder().delete(fullTableName).where("id = ?", threadId);
+      const { sql: threadSql, params: threadParams } = deleteThreadQuery.build();
+      await this.#db.executeQuery({ sql: threadSql, params: threadParams });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "DELETE_THREAD", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to delete thread ${threadId}: ${error instanceof Error ? error.message : String(error)}`,
+          details: { threadId }
+        },
+        error
+      );
+    }
+  }
+  async saveMessages(args) {
+    const { messages } = args;
+    if (messages.length === 0) return { messages: [] };
+    try {
+      const now = /* @__PURE__ */ new Date();
+      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.resourceId) {
+          throw new Error(`Message at index ${i} missing resourceId`);
+        }
+      }
+      const uniqueThreadIds = [...new Set(messages.map((m) => m.threadId))];
+      const threads = await Promise.all(uniqueThreadIds.map((id) => this.getThreadById({ threadId: id })));
+      const missingThreadId = uniqueThreadIds.find((id, i) => !threads[i]);
+      if (missingThreadId) {
+        throw new Error(`Thread ${missingThreadId} not found`);
+      }
+      const messagesToInsert = messages.map((message) => {
+        const createdAt = message.createdAt ? new Date(message.createdAt) : now;
+        return {
+          id: message.id,
+          thread_id: message.threadId,
+          content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+          createdAt: createdAt.toISOString(),
+          role: message.role,
+          type: message.type || "v2",
+          resourceId: message.resourceId
+        };
+      });
+      await Promise.all([
+        this.#db.batchUpsert({
+          tableName: TABLE_MESSAGES,
+          records: messagesToInsert
+        }),
+        // Update updatedAt timestamp for all affected threads
+        ...uniqueThreadIds.map(
+          (tid) => this.#db.executeQuery({
+            sql: `UPDATE ${this.#db.getTableName(TABLE_THREADS)} SET updatedAt = ? WHERE id = ?`,
+            params: [now.toISOString(), tid]
+          })
+        )
+      ]);
+      this.logger.debug(`Saved ${messages.length} messages`);
+      const list = new MessageList().add(messages, "memory");
+      return { messages: list.get.all.db() };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "SAVE_MESSAGES", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to save messages: ${error instanceof Error ? error.message : String(error)}`
+        },
+        error
+      );
+    }
+  }
+  async _getIncludedMessages(include) {
+    if (!include || include.length === 0) return null;
+    const unionQueries = [];
+    const params = [];
+    let paramIdx = 1;
+    const tableName = this.#db.getTableName(TABLE_MESSAGES);
+    for (const inc of include) {
+      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+      unionQueries.push(`
+                SELECT * FROM (
+                  WITH target_thread AS (
+                    SELECT thread_id FROM ${tableName} WHERE id = ?
+                  ),
+                  ordered_messages AS (
+                    SELECT
+                      *,
+                      ROW_NUMBER() OVER (ORDER BY createdAt ASC) AS row_num
+                    FROM ${tableName}
+                    WHERE thread_id = (SELECT thread_id FROM target_thread)
+                  )
+                  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(id, id, id, withNextMessages, withPreviousMessages);
+      paramIdx++;
+    }
+    const finalQuery = unionQueries.join(" UNION ALL ") + " ORDER BY createdAt ASC";
+    const messages = await this.#db.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 listMessagesById({ messageIds }) {
+    if (messageIds.length === 0) return { messages: [] };
+    const fullTableName = this.#db.getTableName(TABLE_MESSAGES);
+    const messages = [];
+    try {
+      const query = createSqlBuilder().select(["id", "content", "role", "type", "createdAt", "thread_id AS threadId", "resourceId"]).from(fullTableName).where(`id in (${messageIds.map(() => "?").join(",")})`, ...messageIds);
+      query.orderBy("createdAt", "DESC");
+      const { sql, params } = query.build();
+      const result = await this.#db.executeQuery({ sql, params });
+      if (Array.isArray(result)) messages.push(...result);
+      const processedMessages = messages.map((message) => {
+        const processedMsg = {};
+        for (const [key, value] of Object.entries(message)) {
+          if (key === `type` && value === `v2`) continue;
+          processedMsg[key] = deserializeValue(value);
+        }
+        return processedMsg;
+      });
+      this.logger.debug(`Retrieved ${messages.length} messages`);
+      const list = new MessageList().add(processedMessages, "memory");
+      return { messages: list.get.all.db() };
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "LIST_MESSAGES_BY_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to retrieve messages by ID: ${error instanceof Error ? error.message : String(error)}`,
+          details: { messageIds: JSON.stringify(messageIds) }
+        },
+        error
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
+      throw mastraError;
+    }
+  }
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    const threadIds = Array.isArray(threadId) ? threadId : [threadId];
+    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "LIST_MESSAGES", "INVALID_THREAD_ID"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: Array.isArray(threadId) ? threadId.join(",") : threadId }
+        },
+        new Error("threadId must be a non-empty string or array of non-empty strings")
+      );
+    }
+    if (page < 0) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "LIST_MESSAGES", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    try {
+      const fullTableName = this.#db.getTableName(TABLE_MESSAGES);
+      const placeholders = threadIds.map(() => "?").join(", ");
+      let query = `
+        SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId
+        FROM ${fullTableName}
+        WHERE thread_id IN (${placeholders})
+      `;
+      const queryParams = [...threadIds];
+      if (resourceId) {
+        query += ` AND resourceId = ?`;
+        queryParams.push(resourceId);
+      }
+      const dateRange = filter?.dateRange;
+      if (dateRange?.start) {
+        const startDate = dateRange.start instanceof Date ? serializeDate(dateRange.start) : serializeDate(new Date(dateRange.start));
+        const startOp = dateRange.startExclusive ? ">" : ">=";
+        query += ` AND createdAt ${startOp} ?`;
+        queryParams.push(startDate);
+      }
+      if (dateRange?.end) {
+        const endDate = dateRange.end instanceof Date ? serializeDate(dateRange.end) : serializeDate(new Date(dateRange.end));
+        const endOp = dateRange.endExclusive ? "<" : "<=";
+        query += ` AND createdAt ${endOp} ?`;
+        queryParams.push(endDate);
+      }
+      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+      query += ` ORDER BY "${field}" ${direction}`;
+      if (perPage !== Number.MAX_SAFE_INTEGER) {
+        query += ` LIMIT ? OFFSET ?`;
+        queryParams.push(perPage, offset);
+      }
+      const results = await this.#db.executeQuery({
+        sql: query,
+        params: queryParams
+      });
+      const paginatedMessages = (isArrayOfRecords(results) ? results : []).map((message) => {
+        const processedMsg = {};
+        for (const [key, value] of Object.entries(message)) {
+          if (key === `type` && value === `v2`) continue;
+          processedMsg[key] = deserializeValue(value);
+        }
+        return processedMsg;
+      });
+      const paginatedCount = paginatedMessages.length;
+      let countQuery = `SELECT count() as count FROM ${fullTableName} WHERE thread_id = ?`;
+      const countParams = [threadId];
+      if (resourceId) {
+        countQuery += ` AND resourceId = ?`;
+        countParams.push(resourceId);
+      }
+      if (dateRange?.start) {
+        const startDate = dateRange.start instanceof Date ? serializeDate(dateRange.start) : serializeDate(new Date(dateRange.start));
+        const startOp = dateRange.startExclusive ? ">" : ">=";
+        countQuery += ` AND createdAt ${startOp} ?`;
+        countParams.push(startDate);
+      }
+      if (dateRange?.end) {
+        const endDate = dateRange.end instanceof Date ? serializeDate(dateRange.end) : serializeDate(new Date(dateRange.end));
+        const endOp = dateRange.endExclusive ? "<" : "<=";
+        countQuery += ` AND createdAt ${endOp} ?`;
+        countParams.push(endDate);
+      }
+      const countResult = await this.#db.executeQuery({
+        sql: countQuery,
+        params: countParams
+      });
+      const total = Number(countResult[0]?.count ?? 0);
+      if (total === 0 && paginatedCount === 0 && (!include || include.length === 0)) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const messageIds = new Set(paginatedMessages.map((m) => m.id));
+      let includeMessages = [];
+      if (include && include.length > 0) {
+        const includeResult = await this._getIncludedMessages(include);
+        if (Array.isArray(includeResult)) {
+          includeMessages = includeResult;
+          for (const includeMsg of includeMessages) {
+            if (!messageIds.has(includeMsg.id)) {
+              paginatedMessages.push(includeMsg);
+              messageIds.add(includeMsg.id);
+            }
+          }
+        }
+      }
+      const list = new MessageList().add(paginatedMessages, "memory");
+      let finalMessages = list.get.all.db();
+      finalMessages = finalMessages.sort((a, b) => {
+        const isDateField = field === "createdAt" || field === "updatedAt";
+        const aValue = isDateField ? new Date(a[field]).getTime() : a[field];
+        const bValue = isDateField ? new Date(b[field]).getTime() : b[field];
+        if (aValue === bValue) {
+          return a.id.localeCompare(b.id);
+        }
+        if (typeof aValue === "number" && typeof bValue === "number") {
+          return direction === "ASC" ? aValue - bValue : bValue - aValue;
+        }
+        return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
+      });
+      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
+      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
+      const hasMore = perPageInput === false ? false : allThreadMessagesReturned ? false : offset + paginatedCount < total;
+      return {
+        messages: finalMessages,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore
+      };
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "LIST_MESSAGES", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to list messages for thread ${Array.isArray(threadId) ? threadId.join(",") : threadId}: ${error instanceof Error ? error.message : String(error)}`,
+          details: {
+            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
+            resourceId: resourceId ?? ""
+          }
+        },
+        error
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
+    }
+  }
+  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.#db.getTableName(TABLE_MESSAGES);
+    const threadsTableName = this.#db.getTableName(TABLE_THREADS);
+    try {
+      const placeholders = messageIds.map(() => "?").join(",");
+      const selectQuery = `SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId FROM ${fullTableName} WHERE id IN (${placeholders})`;
+      const existingMessages = await this.#db.executeQuery({ sql: selectQuery, params: messageIds });
+      if (existingMessages.length === 0) {
+        return [];
+      }
+      const parsedExistingMessages = existingMessages.map((msg) => {
+        let parsedContent = msg.content;
+        if (typeof msg.content === "string") {
+          try {
+            parsedContent = JSON.parse(msg.content);
+          } catch {
+          }
+        }
+        return { ...msg, content: parsedContent };
+      });
+      const existingMessagesMap = new Map(parsedExistingMessages.map((msg) => [msg.id, msg]));
+      const updatedMessages = [];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const update of messages) {
+        const existing = existingMessagesMap.get(update.id);
+        if (!existing) continue;
+        let mergedContent = existing.content;
+        if (update.content) {
+          if (typeof mergedContent === "object" && mergedContent !== null) {
+            mergedContent = {
+              ...mergedContent,
+              ...update.content,
+              metadata: {
+                ...mergedContent.metadata,
+                ...update.content.metadata
+              }
+            };
+          } else {
+            mergedContent = update.content;
+          }
+        }
+        updatedMessages.push({
+          ...existing,
+          ...update,
+          content: mergedContent
+        });
+      }
+      for (const msg of updatedMessages) {
+        const contentStr = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+        const updateQuery = createSqlBuilder().update(fullTableName, ["content", "role", "type"], [contentStr, msg.role, msg.type]).where("id = ?", msg.id);
+        const { sql, params } = updateQuery.build();
+        await this.#db.executeQuery({ sql, params });
+      }
+      const threadIds = [...new Set(updatedMessages.map((m) => m.threadId))];
+      for (const tid of threadIds) {
+        await this.#db.executeQuery({
+          sql: `UPDATE ${threadsTableName} SET updatedAt = ? WHERE id = ?`,
+          params: [now, tid]
+        });
+      }
+      const list = new MessageList().add(updatedMessages, "memory");
+      return list.get.all.db();
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "UPDATE_MESSAGES", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to update messages: ${error instanceof Error ? error.message : String(error)}`,
+          details: { messageIds: JSON.stringify(messageIds) }
+        },
+        error
+      );
+    }
+  }
+  async deleteMessages(messageIds) {
+    if (messageIds.length === 0) return;
+    const fullTableName = this.#db.getTableName(TABLE_MESSAGES);
+    try {
+      const placeholders = messageIds.map(() => "?").join(",");
+      const sql = `DELETE FROM ${fullTableName} WHERE id IN (${placeholders})`;
+      await this.#db.executeQuery({ sql, params: messageIds });
+      this.logger.debug(`Deleted ${messageIds.length} messages`);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "DELETE_MESSAGES", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to delete messages: ${error instanceof Error ? error.message : String(error)}`,
+          details: { messageIds: JSON.stringify(messageIds) }
+        },
+        error
+      );
+    }
+  }
+};
+function transformScoreRow(row) {
+  return transformScoreRow$1(row, {
+    preferredTimestampFields: {
+      createdAt: "createdAtZ",
+      updatedAt: "updatedAtZ"
+    }
+  });
+}
+var ScoresStorageDO = class extends ScoresStorage {
+  #db;
+  constructor(config) {
+    super();
+    this.#db = new DODB(config);
+  }
+  async init() {
+    await this.#db.createTable({ tableName: TABLE_SCORERS, schema: TABLE_SCHEMAS[TABLE_SCORERS] });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: TABLE_SCORERS });
+  }
+  async getScoreById({ id }) {
+    try {
+      const fullTableName = this.#db.getTableName(TABLE_SCORERS);
+      const query = createSqlBuilder().select("*").from(fullTableName).where("id = ?", id);
+      const { sql, params } = query.build();
+      const result = await this.#db.executeQuery({ sql, params, first: true });
+      if (!result) {
+        return null;
+      }
+      return transformScoreRow(result);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "GET_SCORE_BY_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
+  async saveScore(score) {
+    let parsedScore;
+    try {
+      parsedScore = saveScorePayloadSchema.parse(score);
+    } catch (error) {
+      const safeScore = score && typeof score === "object" ? score : {};
+      const safeScorer = safeScore.scorer && typeof safeScore.scorer === "object" ? safeScore.scorer : {};
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "SAVE_SCORE", "VALIDATION_FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: {
+            scorer: typeof safeScorer.id === "string" ? safeScorer.id : String(safeScorer.id ?? "unknown"),
+            entityId: safeScore.entityId ?? "unknown",
+            entityType: safeScore.entityType ?? "unknown",
+            traceId: safeScore.traceId ?? "",
+            spanId: safeScore.spanId ?? ""
+          }
+        },
+        error
+      );
+    }
+    const id = crypto.randomUUID();
+    try {
+      const fullTableName = this.#db.getTableName(TABLE_SCORERS);
+      const serializedRecord = {};
+      for (const [key, value] of Object.entries(parsedScore)) {
+        if (value !== null && value !== void 0) {
+          if (typeof value === "object") {
+            serializedRecord[key] = JSON.stringify(value);
+          } else {
+            serializedRecord[key] = value;
+          }
+        } else {
+          serializedRecord[key] = null;
+        }
+      }
+      const now = /* @__PURE__ */ new Date();
+      serializedRecord.id = id;
+      serializedRecord.createdAt = now.toISOString();
+      serializedRecord.updatedAt = now.toISOString();
+      const columns = Object.keys(serializedRecord);
+      const values = Object.values(serializedRecord);
+      const query = createSqlBuilder().insert(
+        fullTableName,
+        columns,
+        values
+      );
+      const { sql, params } = query.build();
+      await this.#db.executeQuery({ sql, params });
+      return { score: { ...parsedScore, id, createdAt: now, updatedAt: now } };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "SAVE_SCORE", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error
+      );
+    }
+  }
+  async listScoresByScorerId({
+    scorerId,
+    entityId,
+    entityType,
+    source,
+    pagination
+  }) {
+    try {
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+      const fullTableName = this.#db.getTableName(TABLE_SCORERS);
+      const countQuery = createSqlBuilder().count().from(fullTableName).where("scorerId = ?", scorerId);
+      if (entityId) {
+        countQuery.andWhere("entityId = ?", entityId);
+      }
+      if (entityType) {
+        countQuery.andWhere("entityType = ?", entityType);
+      }
+      if (source) {
+        countQuery.andWhere("source = ?", source);
+      }
+      const countResult = await this.#db.executeQuery(countQuery.build());
+      const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
+      if (total === 0) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageForResponse,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const end = perPageInput === false ? total : start + perPage;
+      const limitValue = perPageInput === false ? total : perPage;
+      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("scorerId = ?", scorerId);
+      if (entityId) {
+        selectQuery.andWhere("entityId = ?", entityId);
+      }
+      if (entityType) {
+        selectQuery.andWhere("entityType = ?", entityType);
+      }
+      if (source) {
+        selectQuery.andWhere("source = ?", source);
+      }
+      selectQuery.limit(limitValue).offset(start);
+      const { sql, params } = selectQuery.build();
+      const results = await this.#db.executeQuery({ sql, params });
+      const scores = Array.isArray(results) ? results.map((r) => transformScoreRow(r)) : [];
+      return {
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        },
+        scores
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "GET_SCORES_BY_SCORER_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
+  async listScoresByRunId({
+    runId,
+    pagination
+  }) {
+    try {
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+      const fullTableName = this.#db.getTableName(TABLE_SCORERS);
+      const countQuery = createSqlBuilder().count().from(fullTableName).where("runId = ?", runId);
+      const countResult = await this.#db.executeQuery(countQuery.build());
+      const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
+      if (total === 0) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageForResponse,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const end = perPageInput === false ? total : start + perPage;
+      const limitValue = perPageInput === false ? total : perPage;
+      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("runId = ?", runId).limit(limitValue).offset(start);
+      const { sql, params } = selectQuery.build();
+      const results = await this.#db.executeQuery({ sql, params });
+      const scores = Array.isArray(results) ? results.map((r) => transformScoreRow(r)) : [];
+      return {
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        },
+        scores
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "GET_SCORES_BY_RUN_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
+  async listScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    try {
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+      const fullTableName = this.#db.getTableName(TABLE_SCORERS);
+      const countQuery = createSqlBuilder().count().from(fullTableName).where("entityId = ?", entityId).andWhere("entityType = ?", entityType);
+      const countResult = await this.#db.executeQuery(countQuery.build());
+      const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
+      if (total === 0) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageForResponse,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const end = perPageInput === false ? total : start + perPage;
+      const limitValue = perPageInput === false ? total : perPage;
+      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("entityId = ?", entityId).andWhere("entityType = ?", entityType).limit(limitValue).offset(start);
+      const { sql, params } = selectQuery.build();
+      const results = await this.#db.executeQuery({ sql, params });
+      const scores = Array.isArray(results) ? results.map((r) => transformScoreRow(r)) : [];
+      return {
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        },
+        scores
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "GET_SCORES_BY_ENTITY_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
+  async listScoresBySpan({
+    traceId,
+    spanId,
+    pagination
+  }) {
+    try {
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+      const fullTableName = this.#db.getTableName(TABLE_SCORERS);
+      const countQuery = createSqlBuilder().count().from(fullTableName).where("traceId = ?", traceId).andWhere("spanId = ?", spanId);
+      const countResult = await this.#db.executeQuery(countQuery.build());
+      const total = Array.isArray(countResult) ? Number(countResult?.[0]?.count ?? 0) : Number(countResult?.count ?? 0);
+      if (total === 0) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageForResponse,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const end = perPageInput === false ? total : start + perPage;
+      const limitValue = perPageInput === false ? total : perPage;
+      const selectQuery = createSqlBuilder().select("*").from(fullTableName).where("traceId = ?", traceId).andWhere("spanId = ?", spanId).orderBy("createdAt", "DESC").limit(limitValue).offset(start);
+      const { sql, params } = selectQuery.build();
+      const results = await this.#db.executeQuery({ sql, params });
+      const scores = Array.isArray(results) ? results.map((r) => transformScoreRow(r)) : [];
+      return {
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        },
+        scores
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "GET_SCORES_BY_SPAN", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
+};
+var WorkflowsStorageDO = class extends WorkflowsStorage {
+  #db;
+  constructor(config) {
+    super();
+    this.#db = new DODB(config);
+  }
+  supportsConcurrentUpdates() {
+    return false;
+  }
+  async init() {
+    await this.#db.createTable({ tableName: TABLE_WORKFLOW_SNAPSHOT, schema: TABLE_SCHEMAS[TABLE_WORKFLOW_SNAPSHOT] });
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: TABLE_WORKFLOW_SNAPSHOT });
+  }
+  updateWorkflowResults({
+    // workflowName,
+    // runId,
+    // stepId,
+    // result,
+    // requestContext,
+  }) {
+    throw new Error("Method not implemented.");
+  }
+  updateWorkflowState({
+    // workflowName,
+    // runId,
+    // opts,
+  }) {
+    throw new Error("Method not implemented.");
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    resourceId,
+    snapshot,
+    createdAt,
+    updatedAt
+  }) {
+    const fullTableName = this.#db.getTableName(TABLE_WORKFLOW_SNAPSHOT);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const currentSnapshot = await this.#db.load({
+      tableName: TABLE_WORKFLOW_SNAPSHOT,
+      keys: { workflow_name: workflowName, run_id: runId }
+    });
+    const persisting = currentSnapshot ? {
+      ...currentSnapshot,
+      resourceId,
+      snapshot: JSON.stringify(snapshot),
+      updatedAt: updatedAt ? updatedAt.toISOString() : now
+    } : {
+      workflow_name: workflowName,
+      run_id: runId,
+      resourceId,
+      snapshot: JSON.stringify(snapshot),
+      createdAt: createdAt ? createdAt.toISOString() : now,
+      updatedAt: updatedAt ? updatedAt.toISOString() : now
+    };
+    const processedRecord = await this.#db.processRecord(persisting);
+    const columns = Object.keys(processedRecord);
+    const values = Object.values(processedRecord);
+    const updateMap = {
+      snapshot: "excluded.snapshot",
+      updatedAt: "excluded.updatedAt",
+      resourceId: `COALESCE(excluded.resourceId, ${fullTableName}.resourceId)`
+    };
+    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.#db.executeQuery({ sql, params });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
+          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 });
+    try {
+      const d = await this.#db.load({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        keys: {
+          workflow_name: workflowName,
+          run_id: runId
+        }
+      });
+      return d ? d.snapshot : null;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "LOAD_WORKFLOW_SNAPSHOT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to load workflow snapshot: ${error instanceof Error ? error.message : String(error)}`,
+          details: { workflowName, runId }
+        },
+        error
+      );
+    }
+  }
+  parseWorkflowRun(row) {
+    let parsedSnapshot = row.snapshot;
+    if (typeof parsedSnapshot === "string") {
+      try {
+        parsedSnapshot = JSON.parse(row.snapshot);
+      } catch (e) {
+        this.logger.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+      }
+    }
+    return {
+      workflowName: row.workflow_name,
+      runId: row.run_id,
+      snapshot: parsedSnapshot,
+      createdAt: ensureDate(row.createdAt),
+      updatedAt: ensureDate(row.updatedAt),
+      resourceId: row.resourceId
+    };
+  }
+  async listWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    page,
+    perPage,
+    resourceId,
+    status
+  } = {}) {
+    const fullTableName = this.#db.getTableName(TABLE_WORKFLOW_SNAPSHOT);
+    try {
+      const builder = createSqlBuilder().select().from(fullTableName);
+      const countBuilder = createSqlBuilder().count().from(fullTableName);
+      if (workflowName) {
+        builder.whereAnd("workflow_name = ?", workflowName);
+        countBuilder.whereAnd("workflow_name = ?", workflowName);
+      }
+      if (status) {
+        builder.whereAnd("json_extract(snapshot, '$.status') = ?", status);
+        countBuilder.whereAnd("json_extract(snapshot, '$.status') = ?", status);
+      }
+      if (resourceId) {
+        const hasResourceId = await this.#db.hasColumn(fullTableName, "resourceId");
+        if (hasResourceId) {
+          builder.whereAnd("resourceId = ?", resourceId);
+          countBuilder.whereAnd("resourceId = ?", resourceId);
+        } else {
+          this.logger.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 perPage === "number" && typeof page === "number") {
+        const offset = page * perPage;
+        builder.limit(perPage);
+        builder.offset(offset);
+      }
+      const { sql, params } = builder.build();
+      let total = 0;
+      if (perPage !== void 0 && page !== void 0) {
+        const { sql: countSql, params: countParams } = countBuilder.build();
+        const countResult = await this.#db.executeQuery({
+          sql: countSql,
+          params: countParams,
+          first: true
+        });
+        total = Number(countResult?.count ?? 0);
+      }
+      const results = await this.#db.executeQuery({ sql, params });
+      const runs = (isArrayOfRecords(results) ? results : []).map(
+        (row) => this.parseWorkflowRun(row)
+      );
+      return { runs, total: total || runs.length };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "LIST_WORKFLOW_RUNS", "FAILED"),
+          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.#db.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.#db.executeQuery({ sql, params, first: true });
+      if (!result) return null;
+      return this.parseWorkflowRun(result);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to retrieve workflow run by ID: ${error instanceof Error ? error.message : String(error)}`,
+          details: { runId, workflowName: workflowName ?? "" }
+        },
+        error
+      );
+    }
+  }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    const fullTableName = this.#db.getTableName(TABLE_WORKFLOW_SNAPSHOT);
+    try {
+      const sql = `DELETE FROM ${fullTableName} WHERE workflow_name = ? AND run_id = ?`;
+      const params = [workflowName, runId];
+      await this.#db.executeQuery({ sql, params });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          text: `Failed to delete workflow run by ID: ${error instanceof Error ? error.message : String(error)}`,
+          details: { runId, workflowName }
+        },
+        error
+      );
+    }
+  }
+};
+
+// src/do/index.ts
+var CloudflareDOStorage = class extends MastraCompositeStore {
+  stores;
+  /**
+   * Creates a new CloudflareDOStorage instance
+   * @param config Configuration for Durable Objects SqlStorage access
+   */
+  constructor(config) {
+    try {
+      super({ id: "do-store", name: "DO", disableInit: config.disableInit });
+      if (config.tablePrefix && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(config.tablePrefix)) {
+        throw new Error(
+          "Invalid tablePrefix: must start with a letter or underscore and contain only letters, numbers, and underscores."
+        );
+      }
+      const domainConfig = { sql: config.sql, tablePrefix: config.tablePrefix };
+      this.stores = {
+        memory: new MemoryStorageDO(domainConfig),
+        workflows: new WorkflowsStorageDO(domainConfig),
+        scores: new ScoresStorageDO(domainConfig)
+      };
+      this.logger.info("Using Durable Objects SqlStorage");
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CLOUDFLARE_DO", "INITIALIZATION", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.SYSTEM,
+          text: "Error initializing CloudflareDOStorage"
+        },
+        error
+      );
+    }
+  }
+  /**
+   * Close the database connection
+   * No explicit cleanup needed for DO storage
+   */
+  async close() {
+    this.logger.debug("Closing DO connection");
+  }
+};
+var DOStore = CloudflareDOStorage;
+
+export { CloudflareDOStorage, DODB, DOStore, MemoryStorageDO, ScoresStorageDO, WorkflowsStorageDO };
+//# sourceMappingURL=chunk-NSFHQATX.js.map
+//# sourceMappingURL=chunk-NSFHQATX.js.map