@mastra/cloudflare 1.5.1 → 1.6.0

package/dist/chunk-OMTTR37Z.js

@@ -1,2442 +0,0 @@
-import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
-import { createStorageErrorId, getSqlType, getDefaultValue, BackgroundTasksStorage, TABLE_SCHEMAS, TABLE_BACKGROUND_TASKS, MemoryStorage, 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 { MastraBase } from '@mastra/core/base';
-import { parseSqlIdentifier } from '@mastra/core/utils';
-import { MessageList } from '@mastra/core/agent';
-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/background-tasks/index.ts
-function serializeJson(v) {
-  if (typeof v === "object" && v != null) return JSON.stringify(v);
-  return v ?? void 0;
-}
-function rowToTask(row) {
-  const parseJson = (v) => {
-    if (v == null) return void 0;
-    if (typeof v === "string") {
-      try {
-        return JSON.parse(v);
-      } catch {
-        return v;
-      }
-    }
-    return v;
-  };
-  const asDate = (v) => v ? new Date(String(v)) : void 0;
-  return {
-    id: String(row.id),
-    status: String(row.status),
-    toolName: String(row.tool_name),
-    toolCallId: String(row.tool_call_id),
-    args: parseJson(row.args) ?? {},
-    agentId: String(row.agent_id),
-    threadId: row.thread_id != null ? String(row.thread_id) : void 0,
-    resourceId: row.resource_id != null ? String(row.resource_id) : void 0,
-    runId: String(row.run_id),
-    result: parseJson(row.result),
-    error: parseJson(row.error),
-    suspendPayload: parseJson(row.suspend_payload),
-    retryCount: Number(row.retry_count ?? 0),
-    maxRetries: Number(row.max_retries ?? 0),
-    timeoutMs: Number(row.timeout_ms ?? 3e5),
-    createdAt: asDate(row.createdAt) ?? /* @__PURE__ */ new Date(),
-    startedAt: asDate(row.startedAt),
-    suspendedAt: asDate(row.suspendedAt),
-    completedAt: asDate(row.completedAt)
-  };
-}
-function dateColumnName(col) {
-  return col;
-}
-var BackgroundTasksStorageDO = class extends BackgroundTasksStorage {
-  #db;
-  constructor(config) {
-    super();
-    this.#db = new DODB(config);
-  }
-  async init() {
-    await this.#db.createTable({
-      tableName: TABLE_BACKGROUND_TASKS,
-      schema: TABLE_SCHEMAS[TABLE_BACKGROUND_TASKS]
-    });
-    await this.#db.alterTable({
-      tableName: TABLE_BACKGROUND_TASKS,
-      schema: TABLE_SCHEMAS[TABLE_BACKGROUND_TASKS],
-      ifNotExists: ["suspend_payload", "suspendedAt"]
-    });
-  }
-  async dangerouslyClearAll() {
-    await this.#db.clearTable({ tableName: TABLE_BACKGROUND_TASKS });
-  }
-  async createTask(task) {
-    try {
-      await this.#db.insert({
-        tableName: TABLE_BACKGROUND_TASKS,
-        record: {
-          id: task.id,
-          tool_call_id: task.toolCallId,
-          tool_name: task.toolName,
-          agent_id: task.agentId,
-          thread_id: task.threadId ?? null,
-          resource_id: task.resourceId ?? null,
-          run_id: task.runId,
-          status: task.status,
-          args: serializeJson(task.args),
-          result: serializeJson(task.result),
-          error: serializeJson(task.error),
-          suspend_payload: serializeJson(task.suspendPayload),
-          retry_count: task.retryCount,
-          max_retries: task.maxRetries,
-          timeout_ms: task.timeoutMs,
-          createdAt: task.createdAt.toISOString(),
-          startedAt: task.startedAt?.toISOString() ?? null,
-          suspendedAt: task.suspendedAt?.toISOString() ?? null,
-          completedAt: task.completedAt?.toISOString() ?? null
-        }
-      });
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: createStorageErrorId("CLOUDFLARE_DO", "BACKGROUND_TASKS_CREATE", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
-        },
-        error
-      );
-    }
-  }
-  async updateTask(taskId, update) {
-    const columns = [];
-    const values = [];
-    if ("status" in update) {
-      columns.push("status");
-      values.push(update.status);
-    }
-    if ("result" in update) {
-      columns.push("result");
-      values.push(serializeJson(update.result));
-    }
-    if ("error" in update) {
-      columns.push("error");
-      values.push(serializeJson(update.error));
-    }
-    if ("suspendPayload" in update) {
-      columns.push("suspend_payload");
-      values.push(serializeJson(update.suspendPayload));
-    }
-    if ("retryCount" in update) {
-      columns.push("retry_count");
-      values.push(update.retryCount);
-    }
-    if ("startedAt" in update) {
-      columns.push("startedAt");
-      values.push(update.startedAt?.toISOString() ?? null);
-    }
-    if ("suspendedAt" in update) {
-      columns.push("suspendedAt");
-      values.push(update.suspendedAt?.toISOString() ?? null);
-    }
-    if ("completedAt" in update) {
-      columns.push("completedAt");
-      values.push(update.completedAt?.toISOString() ?? null);
-    }
-    if (columns.length === 0) return;
-    try {
-      const fullTableName = this.#db.getTableName(TABLE_BACKGROUND_TASKS);
-      const query = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", taskId);
-      const { sql, params } = query.build();
-      await this.#db.executeQuery({ sql, params });
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: createStorageErrorId("CLOUDFLARE_DO", "BACKGROUND_TASKS_UPDATE", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
-        },
-        error
-      );
-    }
-  }
-  async getTask(taskId) {
-    try {
-      const fullTableName = this.#db.getTableName(TABLE_BACKGROUND_TASKS);
-      const query = createSqlBuilder().select("*").from(fullTableName).where("id = ?", taskId);
-      const { sql, params } = query.build();
-      const result = await this.#db.executeQuery({ sql, params, first: true });
-      if (!result) return null;
-      const deserialized = {};
-      for (const [k, v] of Object.entries(result)) {
-        deserialized[k] = deserializeValue(v);
-      }
-      return rowToTask(deserialized);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: createStorageErrorId("CLOUDFLARE_DO", "BACKGROUND_TASKS_GET", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
-        },
-        error
-      );
-    }
-  }
-  async listTasks(filter) {
-    try {
-      const fullTableName = this.#db.getTableName(TABLE_BACKGROUND_TASKS);
-      const applyConditions = (builder) => {
-        if (filter.status) {
-          const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
-          const placeholders = statuses.map(() => "?").join(", ");
-          builder.whereAnd(`status IN (${placeholders})`, ...statuses);
-        }
-        if (filter.agentId) builder.whereAnd("agent_id = ?", filter.agentId);
-        if (filter.threadId) builder.whereAnd("thread_id = ?", filter.threadId);
-        if (filter.resourceId) builder.whereAnd("resource_id = ?", filter.resourceId);
-        if (filter.toolName) builder.whereAnd("tool_name = ?", filter.toolName);
-        if (filter.toolCallId) builder.whereAnd("tool_call_id = ?", filter.toolCallId);
-        if (filter.runId) builder.whereAnd("run_id = ?", filter.runId);
-        const dateCol = dateColumnName(filter.dateFilterBy ?? "createdAt");
-        if (filter.fromDate) builder.whereAnd(`${dateCol} >= ?`, filter.fromDate.toISOString());
-        if (filter.toDate) builder.whereAnd(`${dateCol} < ?`, filter.toDate.toISOString());
-      };
-      const countQuery = createSqlBuilder().count().from(fullTableName);
-      applyConditions(countQuery);
-      const { sql: countSql, params: countParams } = countQuery.build();
-      const countResult = await this.#db.executeQuery({ sql: countSql, params: countParams, first: true });
-      const total = Number(countResult?.count ?? 0);
-      const dataQuery = createSqlBuilder().select("*").from(fullTableName);
-      applyConditions(dataQuery);
-      const orderBy = dateColumnName(filter.orderBy ?? "createdAt");
-      const direction = filter.orderDirection === "desc" ? "DESC" : "ASC";
-      dataQuery.orderBy(orderBy, direction);
-      if (filter.perPage != null) {
-        dataQuery.limit(filter.perPage);
-        if (filter.page != null) {
-          dataQuery.offset(filter.page * filter.perPage);
-        }
-      }
-      const { sql, params } = dataQuery.build();
-      const rows = await this.#db.executeQuery({ sql, params });
-      const tasks = (rows ?? []).map((row) => {
-        const deserialized = {};
-        for (const [k, v] of Object.entries(row)) {
-          deserialized[k] = deserializeValue(v);
-        }
-        return rowToTask(deserialized);
-      });
-      return { tasks, total };
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: createStorageErrorId("CLOUDFLARE_DO", "BACKGROUND_TASKS_LIST", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
-        },
-        error
-      );
-    }
-  }
-  async deleteTask(taskId) {
-    try {
-      const fullTableName = this.#db.getTableName(TABLE_BACKGROUND_TASKS);
-      const query = createSqlBuilder().delete(fullTableName).where("id = ?", taskId);
-      const { sql, params } = query.build();
-      await this.#db.executeQuery({ sql, params });
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: createStorageErrorId("CLOUDFLARE_DO", "BACKGROUND_TASKS_DELETE", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
-        },
-        error
-      );
-    }
-  }
-  async deleteTasks(filter) {
-    try {
-      const fullTableName = this.#db.getTableName(TABLE_BACKGROUND_TASKS);
-      const query = createSqlBuilder().delete(fullTableName);
-      if (filter.status) {
-        const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
-        const placeholders = statuses.map(() => "?").join(", ");
-        query.whereAnd(`status IN (${placeholders})`, ...statuses);
-      }
-      if (filter.agentId) query.whereAnd("agent_id = ?", filter.agentId);
-      if (filter.threadId) query.whereAnd("thread_id = ?", filter.threadId);
-      if (filter.resourceId) query.whereAnd("resource_id = ?", filter.resourceId);
-      if (filter.toolName) query.whereAnd("tool_name = ?", filter.toolName);
-      if (filter.toolCallId) query.whereAnd("tool_call_id = ?", filter.toolCallId);
-      if (filter.runId) query.whereAnd("run_id = ?", filter.runId);
-      const dateCol = dateColumnName(filter.dateFilterBy ?? "createdAt");
-      if (filter.fromDate) query.whereAnd(`${dateCol} >= ?`, filter.fromDate.toISOString());
-      if (filter.toDate) query.whereAnd(`${dateCol} < ?`, filter.toDate.toISOString());
-      const { sql, params } = query.build();
-      await this.#db.executeQuery({ sql, params });
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: createStorageErrorId("CLOUDFLARE_DO", "BACKGROUND_TASKS_DELETE_MANY", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
-        },
-        error
-      );
-    }
-  }
-  async getRunningCount() {
-    const { total } = await this.listTasks({ status: "running" });
-    return total;
-  }
-  async getRunningCountByAgent(agentId) {
-    const { total } = await this.listTasks({ status: "running", agentId });
-    return total;
-  }
-};
-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,
-    resourceId
-  }) {
-    const thread = await this.#db.load({
-      tableName: TABLE_THREADS,
-      keys: { id: threadId }
-    });
-    if (!thread || resourceId !== void 0 && thread.resourceId !== resourceId) 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 applyTenancyFilters(query, filters) {
-  if (filters?.organizationId !== void 0) {
-    query.andWhere("organizationId = ?", filters.organizationId);
-  }
-  if (filters?.projectId !== void 0) {
-    query.andWhere("projectId = ?", filters.projectId);
-  }
-}
-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,
-    filters
-  }) {
-    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);
-      }
-      applyTenancyFilters(countQuery, filters);
-      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);
-      }
-      applyTenancyFilters(selectQuery, filters);
-      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,
-    filters
-  }) {
-    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);
-      applyTenancyFilters(countQuery, filters);
-      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);
-      applyTenancyFilters(selectQuery, filters);
-      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_RUN_ID", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
-        },
-        error
-      );
-    }
-  }
-  async listScoresByEntityId({
-    entityId,
-    entityType,
-    pagination,
-    filters
-  }) {
-    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);
-      applyTenancyFilters(countQuery, filters);
-      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);
-      applyTenancyFilters(selectQuery, filters);
-      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_ENTITY_ID", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
-        },
-        error
-      );
-    }
-  }
-  async listScoresBySpan({
-    traceId,
-    spanId,
-    pagination,
-    filters
-  }) {
-    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);
-      applyTenancyFilters(countQuery, filters);
-      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);
-      applyTenancyFilters(selectQuery, filters);
-      selectQuery.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),
-        backgroundTasks: new BackgroundTasksStorageDO(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 { BackgroundTasksStorageDO, CloudflareDOStorage, DODB, DOStore, MemoryStorageDO, ScoresStorageDO, WorkflowsStorageDO };
-//# sourceMappingURL=chunk-OMTTR37Z.js.map
-//# sourceMappingURL=chunk-OMTTR37Z.js.map