@mastra/cloudflare 1.5.1 → 1.6.0

package/dist/do-BDZtdsky.js

@@ -0,0 +1,2272 @@
+import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
+import { BackgroundTasksStorage, MastraCompositeStore, MemoryStorage, ScoresStorage, TABLE_BACKGROUND_TASKS, TABLE_MESSAGES, TABLE_RESOURCES, TABLE_SCHEMAS, TABLE_SCORERS, TABLE_THREADS, TABLE_WORKFLOW_SNAPSHOT, WorkflowsStorage, calculatePagination, createStorageErrorId, ensureDate, getDefaultValue, getSqlType, normalizePerPage, serializeDate, transformScoreRow, validateStorageMetadataFilter } from "@mastra/core/storage";
+import { MastraBase } from "@mastra/core/base";
+import { MessageList } from "@mastra/core/agent";
+import { saveScorePayloadSchema } from "@mastra/core/evals";
+import { parseSqlIdentifier } from "@mastra/core/utils";
+//#region 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 (type === "date" && typeof value === "string") return new Date(value);
+	if (type === "jsonb" && typeof value === "string") try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+	if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+	return value;
+}
+//#endregion
+//#region src/do/storage/sql-builder.ts
+/**
+* SQL Builder class for constructing type-safe SQL queries
+* This helps create maintainable and secure SQL queries with proper parameter handling
+*/
+var SqlBuilder = class {
+	sql = "";
+	params = [];
+	whereAdded = false;
+	select(columns) {
+		if (!columns || Array.isArray(columns) && columns.length === 0) this.sql = "SELECT *";
+		else {
+			const parsedCols = (Array.isArray(columns) ? columns : [columns]).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(table, columns, values) {
+		const parsedTableName = parseSqlIdentifier(table, "table name");
+		const setClause = columns.map((col) => parseSqlIdentifier(col, "column name")).map((col) => `${col} = ?`).join(", ");
+		this.sql = `UPDATE ${parsedTableName} SET ${setClause}`;
+		this.params.push(...values);
+		return this;
+	}
+	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 columns = 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;
+		}).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 jsonPattern = `%"${parseSqlIdentifier(key, "key name")}":"${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();
+}
+const SQL_IDENTIFIER_PATTERN = /^[a-zA-Z0-9_]+(\s+AS\s+[a-zA-Z0-9_]+)?$/;
+/**
+* Parses and returns a valid SQL SELECT column identifier.
+* Allows a single identifier (letters, numbers, underscores), or '*', optionally with 'AS alias'.
+*
+* @param column - The column identifier string to parse.
+* @returns The validated column identifier as a branded type.
+* @throws {Error} If invalid.
+*
+* @example
+* const col = parseSelectIdentifier('user_id'); // Ok
+* parseSelectIdentifier('user_id AS uid'); // Ok
+* parseSelectIdentifier('*'); // Ok
+* parseSelectIdentifier('user id'); // Throws error
+*/
+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;
+}
+//#endregion
+//#region 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 sql = `PRAGMA table_info(${table.startsWith(this.tablePrefix) ? table : `${this.tablePrefix}${table}`});`;
+		const result = await this.executeQuery({
+			sql,
+			params: []
+		});
+		if (!result || !Array.isArray(result)) return false;
+		return result.some((col) => col.name === column || col.name === column.toLowerCase());
+	}
+	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) return cursor.toArray()[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) {
+		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.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";
+			case "jsonb": return "TEXT";
+			case "boolean": return "INTEGER";
+			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]) => {
+				return `${colName} ${this.getSqlType(colDef.type)} ${colDef.nullable === false ? "NOT NULL" : ""} ${colDef.primaryKey ? "PRIMARY KEY" : ""}`.trim();
+			});
+			const tableConstraints = [];
+			if (tableName === TABLE_WORKFLOW_SNAPSHOT) tableConstraints.push("UNIQUE (workflow_name, run_id)");
+			const { sql, params } = createSqlBuilder().createTable(fullTableName, columnDefinitions, tableConstraints).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 { sql, params } = createSqlBuilder().delete(fullTableName).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 sql = `ALTER TABLE ${fullTableName} ADD COLUMN ${columnName} ${this.getSqlType(column.type)} ${this.getDefaultValue(column.type)}`;
+					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 { sql, params } = createSqlBuilder().insert(fullTableName, columns, values).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 { sql, params } = createSqlBuilder().insert(fullTableName, columns, values).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 recordsToInsert = records.slice(i, i + batchSize);
+				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 { sql, params } = createSqlBuilder().insert(fullTableName, columns, values, conflictKeys, recordToUpsert).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);
+		}
+	}
+};
+//#endregion
+//#region 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 { sql, params } = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", taskId).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 { sql, params } = createSqlBuilder().select("*").from(fullTableName).where("id = ?", taskId).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();
+			return {
+				tasks: (await this.#db.executeQuery({
+					sql,
+					params
+				}) ?? []).map((row) => {
+					const deserialized = {};
+					for (const [k, v] of Object.entries(row)) deserialized[k] = deserializeValue(v);
+					return rowToTask(deserialized);
+				}),
+				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 { sql, params } = createSqlBuilder().delete(fullTableName).where("id = ?", taskId).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;
+	}
+};
+//#endregion
+//#region src/do/storage/domains/memory/index.ts
+function addSqliteMetadataFilter(conditions, params, metadataFilter) {
+	if (!metadataFilter) return;
+	for (const [key, value] of Object.entries(metadataFilter)) {
+		const path = `$.metadata.${key}`;
+		conditions.push(`CASE WHEN json_valid(content) THEN json_type(content, ?) IS NOT NULL ELSE 0 END`);
+		params.push(path);
+		addSqliteMetadataValuePredicate(conditions, params, path, value);
+	}
+}
+function addSqliteMetadataValuePredicate(conditions, params, path, value) {
+	if (value === null) {
+		conditions.push(`CASE WHEN json_valid(content) THEN json_type(content, ?) = 'null' ELSE 0 END`);
+		params.push(path);
+		return;
+	}
+	if (typeof value === "string") {
+		conditions.push(`CASE WHEN json_valid(content) THEN json_type(content, ?) = 'text' AND json_extract(content, ?) = ? ELSE 0 END`);
+		params.push(path, path, value);
+		return;
+	}
+	if (typeof value === "number") {
+		conditions.push(`CASE WHEN json_valid(content) THEN json_type(content, ?) IN ('integer', 'real') AND json_extract(content, ?) = ? ELSE 0 END`);
+		params.push(path, path, value);
+		return;
+	}
+	conditions.push(`CASE WHEN json_valid(content) THEN json_type(content, ?) = ? AND json_extract(content, ?) = ? ELSE 0 END`);
+	params.push(path, value ? "true" : "false", path, value ? 1 : 0);
+}
+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 { sql, params } = createSqlBuilder().insert(fullTableName, columns, values, ["id"], {
+			workingMemory: "excluded.workingMemory",
+			metadata: "excluded.metadata",
+			createdAt: "excluded.createdAt",
+			updatedAt: "excluded.updatedAt"
+		}).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 { sql, params } = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", resourceId).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 : /* @__PURE__ */ 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 : /* @__PURE__ */ 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"
+					}
+				}, /* @__PURE__ */ 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);
+			return {
+				threads: (await this.#db.executeQuery(selectQuery.build())).map(mapRowToStorageThreadType),
+				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 { sql, params } = createSqlBuilder().insert(fullTableName, columns, values, ["id"], {
+			resourceId: "excluded.resourceId",
+			title: "excluded.title",
+			metadata: "excluded.metadata",
+			createdAt: "excluded.createdAt",
+			updatedAt: "excluded.updatedAt"
+		}).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 { sql, params } = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", id).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 { sql: messagesSql, params: messagesParams } = createSqlBuilder().delete(messagesTableName).where("thread_id = ?", threadId).build();
+			await this.#db.executeQuery({
+				sql: messagesSql,
+				params: messagesParams
+			});
+			const { sql: threadSql, params: threadParams } = createSqlBuilder().delete(fullTableName).where("id = ?", threadId).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
+			}), ...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`);
+			return { messages: new MessageList().add(messages, "memory").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 [];
+		return 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;
+		});
+	}
+	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`);
+			return { messages: new MessageList().add(processedMessages, "memory").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 }
+		}, /* @__PURE__ */ 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 }
+		}, /* @__PURE__ */ new Error("page must be >= 0"));
+		const perPage = normalizePerPage(perPageInput, 40);
+		const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+		const metadataFilter = validateStorageMetadataFilter(filter?.metadata);
+		try {
+			const fullTableName = this.#db.getTableName(TABLE_MESSAGES);
+			let query = `
+        SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId
+        FROM ${fullTableName}
+        WHERE thread_id IN (${threadIds.map(() => "?").join(", ")})
+      `;
+			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 metadataConditions = [];
+			addSqliteMetadataFilter(metadataConditions, queryParams, metadataFilter);
+			if (metadataConditions.length > 0) query += ` AND ${metadataConditions.join(" AND ")}`;
+			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 countMetadataConditions = [];
+			addSqliteMetadataFilter(countMetadataConditions, countParams, metadataFilter);
+			if (countMetadataConditions.length > 0) countQuery += ` AND ${countMetadataConditions.join(" AND ")}`;
+			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);
+					}
+				}
+			}
+			let finalMessages = new MessageList().add(paginatedMessages, "memory").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 hasMore = perPageInput !== false && (metadataFilter || returnedThreadMessageIds.size < total) && 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 selectQuery = `SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId FROM ${fullTableName} WHERE id IN (${messageIds.map(() => "?").join(",")})`;
+			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 { sql, params } = createSqlBuilder().update(fullTableName, [
+					"content",
+					"role",
+					"type"
+				], [
+					contentStr,
+					msg.role,
+					msg.type
+				]).where("id = ?", msg.id).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]
+			});
+			return new MessageList().add(updatedMessages, "memory").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 sql = `DELETE FROM ${fullTableName} WHERE id IN (${messageIds.map(() => "?").join(",")})`;
+			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);
+		}
+	}
+};
+//#endregion
+//#region src/do/storage/domains/scores/index.ts
+/** Appends multi-tenant scope conditions to a SQL builder query (no-op when no filters). */
+function applyTenancyFilters(query, filters) {
+	if (filters?.organizationId !== void 0) query.andWhere("organizationId = ?", filters.organizationId);
+	if (filters?.projectId !== void 0) query.andWhere("projectId = ?", filters.projectId);
+}
+/**
+* Durable Objects-specific score row transformation.
+* Uses Z-suffix timestamps (createdAtZ, updatedAtZ) when available.
+*/
+function transformScoreRow$1(row) {
+	return transformScoreRow(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 { sql, params } = createSqlBuilder().select("*").from(fullTableName).where("id = ?", id).build();
+			const result = await this.#db.executeQuery({
+				sql,
+				params,
+				first: true
+			});
+			if (!result) return null;
+			return transformScoreRow$1(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 { sql, params } = createSqlBuilder().insert(fullTableName, columns, values).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$1(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$1(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$1(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$1(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);
+		}
+	}
+};
+//#endregion
+//#region src/do/storage/domains/workflows/index.ts
+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({}) {
+		throw new Error("Method not implemented.");
+	}
+	updateWorkflowState({}) {
+		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 { sql, params } = createSqlBuilder().insert(fullTableName, columns, values, ["workflow_name", "run_id"], updateMap).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) if (await this.#db.hasColumn(fullTableName, "resourceId")) {
+				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 sql = `SELECT * FROM ${fullTableName} ${conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : ""} 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);
+		}
+	}
+};
+//#endregion
+//#region src/do/index.ts
+/**
+* Cloudflare Durable Objects storage adapter for Mastra.
+*
+* Uses the synchronous SqlStorage API available in Durable Objects
+* to provide thread-based memory storage, workflow persistence, and scoring.
+*
+* Access domain-specific storage via `getStore()`:
+*
+* @example
+* ```typescript
+* import { DurableObject } from "cloudflare:workers";
+* import { CloudflareDOStorage } from "@mastra/cloudflare/do";
+*
+* class AgentDurableObject extends DurableObject<Env> {
+*   private storage: CloudflareDOStorage;
+*
+*   constructor(ctx: DurableObjectState, env: Env) {
+*     super(ctx, env);
+*     this.storage = new CloudflareDOStorage({
+*       sql: ctx.storage.sql,
+*       tablePrefix: 'mastra_'
+*     });
+*   }
+*
+*   async run() {
+*     const memory = await this.storage.getStore('memory');
+*     await memory?.saveThread({ thread: { id: 'thread-1', ... } });
+*   }
+* }
+* ```
+*/
+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");
+	}
+};
+/**
+* @deprecated Use CloudflareDOStorage instead
+*/
+const DOStore = CloudflareDOStorage;
+//#endregion
+export { MemoryStorageDO as a, ScoresStorageDO as i, DOStore as n, BackgroundTasksStorageDO as o, WorkflowsStorageDO as r, DODB as s, CloudflareDOStorage as t };
+
+//# sourceMappingURL=do-BDZtdsky.js.map