@mastra/cloudflare 1.6.0-alpha.0 → 1.6.0

package/dist/kv-DAbAqe-v.cjs

@@ -0,0 +1,2195 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _mastra_core_error = require("@mastra/core/error");
+let _mastra_core_storage = require("@mastra/core/storage");
+let cloudflare = require("cloudflare");
+cloudflare = __toESM(cloudflare, 1);
+let _mastra_core_base = require("@mastra/core/base");
+let _mastra_core_agent = require("@mastra/core/agent");
+let _mastra_core_evals = require("@mastra/core/evals");
+//#region src/kv/storage/db/index.ts
+/**
+* Resolves CloudflareDomainConfig to CloudflareKVDBConfig.
+* Handles creating a new Cloudflare client if apiToken is provided.
+*/
+function resolveCloudflareConfig(config) {
+	if ("client" in config) return {
+		client: config.client,
+		accountId: config.accountId,
+		namespacePrefix: config.namespacePrefix
+	};
+	if ("bindings" in config) return {
+		bindings: config.bindings,
+		namespacePrefix: config.keyPrefix
+	};
+	return {
+		client: new cloudflare.default({ apiToken: config.apiToken }),
+		accountId: config.accountId,
+		namespacePrefix: config.namespacePrefix
+	};
+}
+var CloudflareKVDB = class extends _mastra_core_base.MastraBase {
+	bindings;
+	client;
+	accountId;
+	namespacePrefix;
+	constructor(config) {
+		super({
+			component: "STORAGE",
+			name: "CLOUDFLARE_KV_DB"
+		});
+		this.bindings = config.bindings;
+		this.namespacePrefix = config.namespacePrefix || "";
+		this.client = config.client;
+		this.accountId = config.accountId;
+	}
+	getBinding(tableName) {
+		if (!this.bindings) throw new Error(`Cannot use Workers API binding for ${tableName}: Store initialized with REST API configuration`);
+		const binding = this.bindings[tableName];
+		if (!binding) throw new Error(`No binding found for namespace ${tableName}`);
+		return binding;
+	}
+	getKey(tableName, record) {
+		const prefix = this.namespacePrefix ? `${this.namespacePrefix}:` : "";
+		switch (tableName) {
+			case _mastra_core_storage.TABLE_THREADS:
+				if (!record.id) throw new Error("Thread ID is required");
+				return `${prefix}${tableName}:${record.id}`;
+			case _mastra_core_storage.TABLE_MESSAGES:
+				if (!record.threadId || !record.id) throw new Error("Thread ID and Message ID are required");
+				return `${prefix}${tableName}:${record.threadId}:${record.id}`;
+			case _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT:
+				if (!record.workflow_name || !record.run_id) throw new Error("Workflow name, and run ID are required");
+				let key = `${prefix}${tableName}:${record.workflow_name}:${record.run_id}`;
+				if (record.resourceId) key = `${key}:${record.resourceId}`;
+				return key;
+			case _mastra_core_storage.TABLE_TRACES:
+				if (!record.id) throw new Error("Trace ID is required");
+				return `${prefix}${tableName}:${record.id}`;
+			case _mastra_core_storage.TABLE_SCORERS:
+				if (!record.id) throw new Error("Score ID is required");
+				return `${prefix}${tableName}:${record.id}`;
+			default: throw new Error(`Unsupported table: ${tableName}`);
+		}
+	}
+	getSchemaKey(tableName) {
+		return `${this.namespacePrefix ? `${this.namespacePrefix}:` : ""}schema:${tableName}`;
+	}
+	/**
+	* Helper to safely parse data from KV storage
+	*/
+	safeParse(text) {
+		if (!text) return null;
+		try {
+			const data = JSON.parse(text);
+			if (data && typeof data === "object" && "value" in data) {
+				if (typeof data.value === "string") try {
+					return JSON.parse(data.value);
+				} catch {
+					return data.value;
+				}
+				return null;
+			}
+			return data;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.logger.error("Failed to parse text:", {
+				message,
+				text
+			});
+			return null;
+		}
+	}
+	async createNamespaceById(title) {
+		if (this.bindings) return {
+			id: title,
+			title,
+			supports_url_encoding: true
+		};
+		return await this.client.kv.namespaces.create({
+			account_id: this.accountId,
+			title
+		});
+	}
+	async createNamespace(namespaceName) {
+		try {
+			return (await this.createNamespaceById(namespaceName)).id;
+		} catch (error) {
+			if (error.message && error.message.includes("already exists")) {
+				const namespace = (await this.listNamespaces()).result.find((ns) => ns.title === namespaceName);
+				if (namespace) return namespace.id;
+			}
+			this.logger.error("Error creating namespace:", error);
+			throw new Error(`Failed to create namespace ${namespaceName}: ${error.message}`);
+		}
+	}
+	async listNamespaces() {
+		if (this.bindings) return { result: Object.keys(this.bindings).map((name) => ({
+			id: name,
+			title: name,
+			supports_url_encoding: true
+		})) };
+		let allNamespaces = [];
+		let currentPage = 1;
+		const perPage = 50;
+		let morePagesExist = true;
+		while (morePagesExist) {
+			const response = await this.client.kv.namespaces.list({
+				account_id: this.accountId,
+				page: currentPage,
+				per_page: perPage
+			});
+			if (response.result) allNamespaces = allNamespaces.concat(response.result);
+			morePagesExist = response.result ? response.result.length === perPage : false;
+			if (morePagesExist) currentPage++;
+		}
+		return { result: allNamespaces };
+	}
+	async getNamespaceIdByName(namespaceName) {
+		try {
+			const namespace = (await this.listNamespaces()).result.find((ns) => ns.title === namespaceName);
+			return namespace ? namespace.id : null;
+		} catch (error) {
+			this.logger.error(`Failed to get namespace ID for ${namespaceName}:`, error);
+			return null;
+		}
+	}
+	async getOrCreateNamespaceId(namespaceName) {
+		let namespaceId = await this.getNamespaceIdByName(namespaceName);
+		if (!namespaceId) namespaceId = await this.createNamespace(namespaceName);
+		return namespaceId;
+	}
+	async getNamespaceId(tableName) {
+		const prefix = this.namespacePrefix ? `${this.namespacePrefix}_` : "";
+		try {
+			return await this.getOrCreateNamespaceId(`${prefix}${tableName}`);
+		} catch (error) {
+			this.logger.error("Error fetching namespace ID:", error);
+			throw new Error(`Failed to fetch namespace ID for table ${tableName}: ${error.message}`);
+		}
+	}
+	async getNamespaceValue(tableName, key) {
+		try {
+			if (this.bindings) {
+				const result = await this.getBinding(tableName).getWithMetadata(key, "text");
+				if (!result) return null;
+				return JSON.stringify(result);
+			} else {
+				const namespaceId = await this.getNamespaceId(tableName);
+				return await (await this.client.kv.namespaces.values.get(namespaceId, key, { account_id: this.accountId })).text();
+			}
+		} catch (error) {
+			if (error.message && error.message.includes("key not found")) return null;
+			const message = error instanceof Error ? error.message : String(error);
+			this.logger.error(`Failed to get value for ${tableName} ${key}:`, { message });
+			throw error;
+		}
+	}
+	async getKV(tableName, key) {
+		try {
+			const text = await this.getNamespaceValue(tableName, key);
+			return this.safeParse(text);
+		} catch (error) {
+			this.logger.error(`Failed to get KV value for ${tableName}:${key}:`, error);
+			throw new Error(`Failed to get KV value: ${error.message}`);
+		}
+	}
+	async getTableSchema(tableName) {
+		try {
+			const schemaKey = this.getSchemaKey(tableName);
+			return await this.getKV(tableName, schemaKey);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.logger.error(`Failed to get schema for ${tableName}:`, { message });
+			return null;
+		}
+	}
+	validateColumnValue(value, column) {
+		if (value === void 0 || value === null) return column.nullable ?? false;
+		switch (column.type) {
+			case "text":
+			case "uuid": return typeof value === "string";
+			case "integer":
+			case "bigint": return typeof value === "number";
+			case "timestamp": return value instanceof Date || typeof value === "string" && !isNaN(Date.parse(value));
+			case "jsonb":
+				if (typeof value !== "object") return false;
+				try {
+					JSON.stringify(value);
+					return true;
+				} catch {
+					return false;
+				}
+			default: return false;
+		}
+	}
+	async validateAgainstSchema(record, schema) {
+		try {
+			if (!schema || typeof schema !== "object" || schema.value === null) throw new Error("Invalid schema format");
+			for (const [columnName, column] of Object.entries(schema)) {
+				const value = record[columnName];
+				if (column.primaryKey && (value === void 0 || value === null)) throw new Error(`Missing primary key value for column ${columnName}`);
+				if (!this.validateColumnValue(value, column)) {
+					const valueType = value === null ? "null" : typeof value;
+					throw new Error(`Invalid value for column ${columnName}: expected ${column.type}, got ${valueType}`);
+				}
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.logger.error(`Error validating record against schema:`, {
+				message,
+				record,
+				schema
+			});
+			throw error;
+		}
+	}
+	async validateRecord(record, tableName) {
+		try {
+			if (!record || typeof record !== "object") throw new Error("Record must be an object");
+			const recordTyped = record;
+			const schema = await this.getTableSchema(tableName);
+			if (schema) {
+				await this.validateAgainstSchema(recordTyped, schema);
+				return;
+			}
+			switch (tableName) {
+				case _mastra_core_storage.TABLE_THREADS:
+					if (!("id" in recordTyped) || !("resourceId" in recordTyped) || !("title" in recordTyped)) throw new Error("Thread record missing required fields");
+					break;
+				case _mastra_core_storage.TABLE_MESSAGES:
+					if (!("id" in recordTyped) || !("threadId" in recordTyped) || !("content" in recordTyped) || !("role" in recordTyped)) throw new Error("Message record missing required fields");
+					break;
+				case _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT:
+					if (!("workflow_name" in recordTyped) || !("run_id" in recordTyped)) throw new Error("Workflow record missing required fields");
+					break;
+				case _mastra_core_storage.TABLE_TRACES:
+					if (!("id" in recordTyped)) throw new Error("Trace record missing required fields");
+					break;
+				case _mastra_core_storage.TABLE_SCORERS:
+					if (!("id" in recordTyped) || !("scorerId" in recordTyped)) throw new Error("Score record missing required fields");
+					break;
+				default: throw new Error(`Unknown table type: ${tableName}`);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.logger.error(`Failed to validate record for ${tableName}:`, {
+				message,
+				record
+			});
+			throw error;
+		}
+	}
+	async insert({ tableName, record }) {
+		try {
+			const key = this.getKey(tableName, record);
+			const processedRecord = { ...record };
+			await this.validateRecord(processedRecord, tableName);
+			await this.putKV({
+				tableName,
+				key,
+				value: processedRecord
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "INSERT", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async load({ tableName, keys }) {
+		try {
+			const key = this.getKey(tableName, keys);
+			const data = await this.getKV(tableName, key);
+			if (!data) return null;
+			return data;
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "LOAD", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+			this.logger?.trackException(mastraError);
+			this.logger?.error(mastraError.toString());
+			return null;
+		}
+	}
+	async batchInsert(input) {
+		if (!input.records || input.records.length === 0) return;
+		try {
+			await Promise.all(input.records.map(async (record) => {
+				const key = this.getKey(input.tableName, record);
+				await this.putKV({
+					tableName: input.tableName,
+					key,
+					value: record
+				});
+			}));
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "BATCH_INSERT", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Error in batch insert for table ${input.tableName}`,
+				details: { tableName: input.tableName }
+			}, error);
+		}
+	}
+	safeSerialize(data) {
+		return typeof data === "string" ? data : JSON.stringify(data);
+	}
+	async putNamespaceValue({ tableName, key, value, metadata }) {
+		try {
+			const serializedValue = this.safeSerialize(value);
+			const serializedMetadata = metadata ? this.safeSerialize(metadata) : "";
+			if (this.bindings) await this.getBinding(tableName).put(key, serializedValue, { metadata: serializedMetadata });
+			else {
+				const namespaceId = await this.getNamespaceId(tableName);
+				await this.client.kv.namespaces.values.update(namespaceId, key, {
+					account_id: this.accountId,
+					value: serializedValue,
+					metadata: serializedMetadata
+				});
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.logger.error(`Failed to put value for ${tableName} ${key}:`, { message });
+			throw error;
+		}
+	}
+	async putKV({ tableName, key, value, metadata }) {
+		try {
+			await this.putNamespaceValue({
+				tableName,
+				key,
+				value,
+				metadata
+			});
+		} catch (error) {
+			this.logger.error(`Failed to put KV value for ${tableName}:${key}:`, error);
+			throw new Error(`Failed to put KV value: ${error.message}`);
+		}
+	}
+	async createTable({ tableName, schema }) {
+		try {
+			const schemaKey = this.getSchemaKey(tableName);
+			const metadata = {
+				type: "table_schema",
+				tableName,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			await this.putKV({
+				tableName,
+				key: schemaKey,
+				value: schema,
+				metadata
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "CREATE_TABLE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async clearTable({ tableName }) {
+		try {
+			const keys = await this.listKV(tableName);
+			if (keys.length > 0) await Promise.all(keys.map((keyObj) => this.deleteKV(tableName, keyObj.name)));
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "CLEAR_TABLE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async dropTable({ tableName }) {
+		try {
+			const keys = await this.listKV(tableName);
+			if (keys.length > 0) await Promise.all(keys.map((keyObj) => this.deleteKV(tableName, keyObj.name)));
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "DROP_TABLE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async listNamespaceKeys(tableName, options) {
+		try {
+			if (this.bindings) return (await this.getBinding(tableName).list({
+				limit: options?.limit || 1e3,
+				prefix: options?.prefix
+			})).keys;
+			else {
+				const namespaceId = await this.getNamespaceId(tableName);
+				return (await this.client.kv.namespaces.keys.list(namespaceId, {
+					account_id: this.accountId,
+					limit: options?.limit || 1e3,
+					prefix: options?.prefix
+				})).result;
+			}
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "LIST_NAMESPACE_KEYS", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async deleteNamespaceValue(tableName, key) {
+		if (this.bindings) await this.getBinding(tableName).delete(key);
+		else {
+			const namespaceId = await this.getNamespaceId(tableName);
+			await this.client.kv.namespaces.values.delete(namespaceId, key, { account_id: this.accountId });
+		}
+	}
+	async deleteKV(tableName, key) {
+		try {
+			await this.deleteNamespaceValue(tableName, key);
+		} catch (error) {
+			this.logger.error(`Failed to delete KV value for ${tableName}:${key}:`, error);
+			throw new Error(`Failed to delete KV value: ${error.message}`);
+		}
+	}
+	async listKV(tableName, options) {
+		try {
+			return await this.listNamespaceKeys(tableName, options);
+		} catch (error) {
+			this.logger.error(`Failed to list KV for ${tableName}:`, error);
+			throw new Error(`Failed to list KV: ${error.message}`);
+		}
+	}
+};
+//#endregion
+//#region src/kv/storage/domains/background-tasks/index.ts
+function toRecord(task) {
+	return {
+		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: task.args,
+		result: task.result ?? null,
+		error: task.error ?? null,
+		suspend_payload: task.suspendPayload ?? null,
+		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
+	};
+}
+function fromRecord(record) {
+	return {
+		id: record.id,
+		status: record.status,
+		toolName: record.tool_name,
+		toolCallId: record.tool_call_id,
+		args: record.args ?? {},
+		agentId: record.agent_id,
+		threadId: record.thread_id ?? void 0,
+		resourceId: record.resource_id ?? void 0,
+		runId: record.run_id ?? "",
+		result: record.result ?? void 0,
+		error: record.error ?? void 0,
+		suspendPayload: record.suspend_payload ?? void 0,
+		retryCount: Number(record.retry_count ?? 0),
+		maxRetries: Number(record.max_retries ?? 0),
+		timeoutMs: Number(record.timeout_ms ?? 3e5),
+		createdAt: new Date(record.createdAt),
+		startedAt: record.startedAt ? new Date(record.startedAt) : void 0,
+		suspendedAt: record.suspendedAt ? new Date(record.suspendedAt) : void 0,
+		completedAt: record.completedAt ? new Date(record.completedAt) : void 0
+	};
+}
+var BackgroundTasksStorageCloudflare = class extends _mastra_core_storage.BackgroundTasksStorage {
+	#db;
+	constructor(config) {
+		super();
+		this.#db = new CloudflareKVDB(resolveCloudflareConfig(config));
+	}
+	async dangerouslyClearAll() {
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_BACKGROUND_TASKS });
+	}
+	async createTask(task) {
+		await this.#db.putKV({
+			tableName: _mastra_core_storage.TABLE_BACKGROUND_TASKS,
+			key: task.id,
+			value: toRecord(task)
+		});
+	}
+	async updateTask(taskId, update) {
+		const existing = await this.getTask(taskId);
+		if (!existing) return;
+		const merged = { ...existing };
+		if ("status" in update) merged.status = update.status;
+		if ("result" in update) merged.result = update.result;
+		if ("error" in update) merged.error = update.error;
+		if ("suspendPayload" in update) merged.suspendPayload = update.suspendPayload;
+		if ("retryCount" in update) merged.retryCount = update.retryCount;
+		if ("startedAt" in update) merged.startedAt = update.startedAt;
+		if ("suspendedAt" in update) merged.suspendedAt = update.suspendedAt;
+		if ("completedAt" in update) merged.completedAt = update.completedAt;
+		await this.#db.putKV({
+			tableName: _mastra_core_storage.TABLE_BACKGROUND_TASKS,
+			key: taskId,
+			value: toRecord(merged)
+		});
+	}
+	async getTask(taskId) {
+		const data = await this.#db.getKV(_mastra_core_storage.TABLE_BACKGROUND_TASKS, taskId);
+		return data ? fromRecord(data) : null;
+	}
+	async listTasks(filter) {
+		const keys = await this.#db.listKV(_mastra_core_storage.TABLE_BACKGROUND_TASKS);
+		if (keys.length === 0) return {
+			tasks: [],
+			total: 0
+		};
+		let tasks = (await Promise.all(keys.map((k) => this.#db.getKV(_mastra_core_storage.TABLE_BACKGROUND_TASKS, k.name)))).filter(Boolean).map((r) => fromRecord(r));
+		if (filter.status) {
+			const s = Array.isArray(filter.status) ? filter.status : [filter.status];
+			tasks = tasks.filter((t) => s.includes(t.status));
+		}
+		if (filter.agentId) tasks = tasks.filter((t) => t.agentId === filter.agentId);
+		if (filter.threadId) tasks = tasks.filter((t) => t.threadId === filter.threadId);
+		if (filter.toolName) tasks = tasks.filter((t) => t.toolName === filter.toolName);
+		if (filter.toolCallId) tasks = tasks.filter((t) => t.toolCallId === filter.toolCallId);
+		if (filter.runId) tasks = tasks.filter((t) => t.runId === filter.runId);
+		const dateCol = filter.dateFilterBy ?? "createdAt";
+		if (filter.fromDate) tasks = tasks.filter((t) => {
+			const val = t[dateCol];
+			return val != null && val >= filter.fromDate;
+		});
+		if (filter.toDate) tasks = tasks.filter((t) => {
+			const val = t[dateCol];
+			return val != null && val < filter.toDate;
+		});
+		const orderBy = filter.orderBy ?? "createdAt";
+		const dir = filter.orderDirection === "desc" ? -1 : 1;
+		tasks.sort((a, b) => ((a[orderBy]?.getTime() ?? 0) - (b[orderBy]?.getTime() ?? 0)) * dir);
+		const total = tasks.length;
+		if (filter.page != null && filter.perPage != null) {
+			const start = filter.page * filter.perPage;
+			tasks = tasks.slice(start, start + filter.perPage);
+		} else if (filter.perPage != null) tasks = tasks.slice(0, filter.perPage);
+		return {
+			tasks,
+			total
+		};
+	}
+	async deleteTask(taskId) {
+		await this.#db.deleteKV(_mastra_core_storage.TABLE_BACKGROUND_TASKS, taskId);
+	}
+	async deleteTasks(filter) {
+		const { tasks } = await this.listTasks(filter);
+		await Promise.all(tasks.map((t) => this.#db.deleteKV(_mastra_core_storage.TABLE_BACKGROUND_TASKS, t.id)));
+	}
+	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/kv/storage/domains/memory/index.ts
+var MemoryStorageCloudflare = class extends _mastra_core_storage.MemoryStorage {
+	#db;
+	constructor(config) {
+		super();
+		this.#db = new CloudflareKVDB(resolveCloudflareConfig(config));
+	}
+	async init() {}
+	async dangerouslyClearAll() {
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_MESSAGES });
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_THREADS });
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_RESOURCES });
+	}
+	ensureMetadata(metadata) {
+		if (!metadata) return void 0;
+		return typeof metadata === "string" ? JSON.parse(metadata) : metadata;
+	}
+	/**
+	* Summarizes message content without exposing raw data (for logging).
+	* Returns type, length, and keys only to prevent PII leakage.
+	*/
+	summarizeMessageContent(content) {
+		if (!content) return { type: "undefined" };
+		if (typeof content === "string") return {
+			type: "string",
+			length: content.length
+		};
+		if (Array.isArray(content)) return {
+			type: "array",
+			length: content.length
+		};
+		if (typeof content === "object") return {
+			type: "object",
+			keys: Object.keys(content)
+		};
+		return { type: typeof content };
+	}
+	async getThreadById({ threadId, resourceId }) {
+		const thread = await this.#db.load({
+			tableName: _mastra_core_storage.TABLE_THREADS,
+			keys: { id: threadId }
+		});
+		if (!thread || resourceId !== void 0 && thread.resourceId !== resourceId) return null;
+		try {
+			return {
+				...thread,
+				createdAt: (0, _mastra_core_storage.ensureDate)(thread.createdAt),
+				updatedAt: (0, _mastra_core_storage.ensureDate)(thread.updatedAt),
+				metadata: this.ensureMetadata(thread.metadata)
+			};
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "GET_THREAD_BY_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { threadId }
+			}, error);
+			this.logger?.trackException(mastraError);
+			this.logger?.error(mastraError.toString());
+			return null;
+		}
+	}
+	async listThreads(args) {
+		const { page = 0, perPage: perPageInput, orderBy, filter } = args;
+		try {
+			this.validatePaginationInput(page, perPageInput ?? 100);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "LIST_THREADS", "INVALID_PAGE"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.USER,
+				details: {
+					page,
+					...perPageInput !== void 0 && { perPage: perPageInput }
+				}
+			}, error instanceof Error ? error : /* @__PURE__ */ new Error("Invalid pagination parameters"));
+		}
+		const perPage = (0, _mastra_core_storage.normalizePerPage)(perPageInput, 100);
+		try {
+			const { offset, perPage: perPageForResponse } = (0, _mastra_core_storage.calculatePagination)(page, perPageInput, perPage);
+			const { field, direction } = this.parseOrderBy(orderBy);
+			const prefix = this.#db.namespacePrefix ? `${this.#db.namespacePrefix}:` : "";
+			const keyObjs = await this.#db.listKV(_mastra_core_storage.TABLE_THREADS, { prefix: `${prefix}${_mastra_core_storage.TABLE_THREADS}` });
+			const threads = [];
+			for (const { name: key } of keyObjs) {
+				const data = await this.#db.getKV(_mastra_core_storage.TABLE_THREADS, key);
+				if (!data) continue;
+				if (filter?.resourceId && data.resourceId !== filter.resourceId) continue;
+				if (filter?.metadata && Object.keys(filter.metadata).length > 0) {
+					const metadata = this.ensureMetadata(data.metadata);
+					if (!metadata) continue;
+					if (!Object.entries(filter.metadata).every(([key, value]) => metadata[key] === value)) continue;
+				}
+				threads.push(data);
+			}
+			threads.sort((a, b) => {
+				const aTime = new Date(a[field] || 0).getTime();
+				const bTime = new Date(b[field] || 0).getTime();
+				return direction === "ASC" ? aTime - bTime : bTime - aTime;
+			});
+			const end = perPageInput === false ? threads.length : offset + perPage;
+			const paginatedThreads = threads.slice(offset, end);
+			return {
+				page,
+				perPage: perPageForResponse,
+				total: threads.length,
+				hasMore: perPageInput === false ? false : offset + perPage < threads.length,
+				threads: paginatedThreads
+			};
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "LIST_THREADS", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: "Failed to list threads with filters"
+			}, error);
+		}
+	}
+	async saveThread({ thread }) {
+		try {
+			await this.#db.insert({
+				tableName: _mastra_core_storage.TABLE_THREADS,
+				record: thread
+			});
+			return thread;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "SAVE_THREAD", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { threadId: thread.id }
+			}, error);
+		}
+	}
+	async updateThread({ id, title, metadata }) {
+		try {
+			const thread = await this.getThreadById({ threadId: id });
+			if (!thread) throw new Error(`Thread ${id} not found`);
+			const updatedThread = {
+				...thread,
+				title,
+				metadata: this.ensureMetadata({
+					...thread.metadata ?? {},
+					...metadata
+				}),
+				updatedAt: /* @__PURE__ */ new Date()
+			};
+			await this.#db.insert({
+				tableName: _mastra_core_storage.TABLE_THREADS,
+				record: updatedThread
+			});
+			return updatedThread;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "UPDATE_THREAD", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					threadId: id,
+					title
+				}
+			}, error);
+		}
+	}
+	getMessageKey(threadId, messageId) {
+		try {
+			return this.#db.getKey(_mastra_core_storage.TABLE_MESSAGES, {
+				threadId,
+				id: messageId
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.logger?.error(`Error getting message key for thread ${threadId} and message ${messageId}:`, { message });
+			throw error;
+		}
+	}
+	getThreadMessagesKey(threadId) {
+		try {
+			return this.#db.getKey(_mastra_core_storage.TABLE_MESSAGES, {
+				threadId,
+				id: "messages"
+			});
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			this.logger?.error(`Error getting thread messages key for thread ${threadId}:`, { message });
+			throw error;
+		}
+	}
+	async deleteThread({ threadId }) {
+		try {
+			if (!await this.getThreadById({ threadId })) throw new Error(`Thread ${threadId} not found`);
+			const threadMessageKeys = (await this.#db.listKV(_mastra_core_storage.TABLE_MESSAGES)).filter((key) => key.name.includes(`${_mastra_core_storage.TABLE_MESSAGES}:${threadId}:`));
+			await Promise.all([
+				this.#db.deleteKV(_mastra_core_storage.TABLE_MESSAGES, this.getThreadMessagesKey(threadId)),
+				...threadMessageKeys.map((key) => this.#db.deleteKV(_mastra_core_storage.TABLE_MESSAGES, key.name)),
+				this.#db.deleteKV(_mastra_core_storage.TABLE_THREADS, this.#db.getKey(_mastra_core_storage.TABLE_THREADS, { id: threadId }))
+			]);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "DELETE_THREAD", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { threadId }
+			}, error);
+		}
+	}
+	/**
+	* Searches all threads in the KV store to find a message by its ID.
+	*
+	* **Performance Warning**: This method sequentially scans all threads to locate
+	* the message. For stores with many threads, this can result in significant
+	* latency and API calls. When possible, callers should provide the `threadId`
+	* directly to avoid this full scan.
+	*
+	* @param messageId - The globally unique message ID to search for
+	* @returns The message with its threadId if found, null otherwise
+	*/
+	async findMessageInAnyThread(messageId) {
+		try {
+			const prefix = this.#db.namespacePrefix ? `${this.#db.namespacePrefix}:` : "";
+			const threadKeys = await this.#db.listKV(_mastra_core_storage.TABLE_THREADS, { prefix: `${prefix}${_mastra_core_storage.TABLE_THREADS}` });
+			for (const { name: threadKey } of threadKeys) {
+				const threadId = threadKey.split(":").pop();
+				if (!threadId || threadId === "messages") continue;
+				const messageKey = this.getMessageKey(threadId, messageId);
+				const message = await this.#db.getKV(_mastra_core_storage.TABLE_MESSAGES, messageKey);
+				if (message) return {
+					...message,
+					threadId
+				};
+			}
+			return null;
+		} catch (error) {
+			this.logger?.error(`Error finding message ${messageId} in any thread:`, error);
+			return null;
+		}
+	}
+	/**
+	* Queue for serializing sorted order updates.
+	* Updates the sorted order for a given key. This operation is eventually consistent.
+	*/
+	updateQueue = /* @__PURE__ */ new Map();
+	async updateSorting(threadMessages) {
+		return threadMessages.map((msg) => ({
+			message: msg,
+			score: msg._index !== void 0 ? msg._index : msg.createdAt.getTime()
+		})).sort((a, b) => a.score - b.score).map((item) => ({
+			id: item.message.id,
+			score: item.score
+		}));
+	}
+	/**
+	* Updates the sorted order for a given key. This operation is eventually consistent.
+	* Note: Operations on the same orderKey are serialized using a queue to prevent
+	* concurrent updates from conflicting with each other.
+	*/
+	async updateSortedMessages(orderKey, newEntries) {
+		const nextPromise = (this.updateQueue.get(orderKey) || Promise.resolve()).then(async () => {
+			try {
+				const currentOrder = await this.getSortedMessages(orderKey);
+				const orderMap = new Map(currentOrder.map((entry) => [entry.id, entry]));
+				for (const entry of newEntries) orderMap.set(entry.id, entry);
+				const updatedOrder = Array.from(orderMap.values()).sort((a, b) => a.score - b.score);
+				await this.#db.putKV({
+					tableName: _mastra_core_storage.TABLE_MESSAGES,
+					key: orderKey,
+					value: JSON.stringify(updatedOrder)
+				});
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				this.logger?.error(`Error updating sorted order for key ${orderKey}:`, { message });
+				throw error;
+			} finally {
+				if (this.updateQueue.get(orderKey) === nextPromise) this.updateQueue.delete(orderKey);
+			}
+		});
+		this.updateQueue.set(orderKey, nextPromise);
+		return nextPromise;
+	}
+	async getSortedMessages(orderKey) {
+		const raw = await this.#db.getKV(_mastra_core_storage.TABLE_MESSAGES, orderKey);
+		if (!raw) return [];
+		try {
+			const arr = JSON.parse(typeof raw === "string" ? raw : JSON.stringify(raw));
+			return Array.isArray(arr) ? arr : [];
+		} catch (e) {
+			this.logger?.error(`Error parsing order data for key ${orderKey}:`, { e });
+			return [];
+		}
+	}
+	async migrateMessage(messageId, fromThreadId, toThreadId) {
+		try {
+			const oldMessageKey = this.getMessageKey(fromThreadId, messageId);
+			const message = await this.#db.getKV(_mastra_core_storage.TABLE_MESSAGES, oldMessageKey);
+			if (!message) return;
+			const updatedMessage = {
+				...message,
+				threadId: toThreadId
+			};
+			const newMessageKey = this.getMessageKey(toThreadId, messageId);
+			await this.#db.putKV({
+				tableName: _mastra_core_storage.TABLE_MESSAGES,
+				key: newMessageKey,
+				value: updatedMessage
+			});
+			const oldOrderKey = this.getThreadMessagesKey(fromThreadId);
+			const filteredEntries = (await this.getSortedMessages(oldOrderKey)).filter((entry) => entry.id !== messageId);
+			await this.updateSortedMessages(oldOrderKey, filteredEntries);
+			const newOrderKey = this.getThreadMessagesKey(toThreadId);
+			const newEntries = await this.getSortedMessages(newOrderKey);
+			const newEntry = {
+				id: messageId,
+				score: Date.now()
+			};
+			newEntries.push(newEntry);
+			await this.updateSortedMessages(newOrderKey, newEntries);
+			await this.#db.deleteKV(_mastra_core_storage.TABLE_MESSAGES, oldMessageKey);
+		} catch (error) {
+			this.logger?.error(`Error migrating message ${messageId} from ${fromThreadId} to ${toThreadId}:`, error);
+			throw error;
+		}
+	}
+	async saveMessages(args) {
+		const { messages } = args;
+		if (!Array.isArray(messages) || messages.length === 0) return { messages: [] };
+		try {
+			const validatedMessages = messages.map((message, index) => {
+				const errors = [];
+				if (!message.id) errors.push("id is required");
+				if (!message.threadId) errors.push("threadId is required");
+				if (!message.content) errors.push("content is required");
+				if (!message.role) errors.push("role is required");
+				if (!message.createdAt) errors.push("createdAt is required");
+				if (message.resourceId === null || message.resourceId === void 0) errors.push("resourceId is required");
+				if (errors.length > 0) throw new Error(`Invalid message at index ${index}: ${errors.join(", ")}`);
+				return {
+					...message,
+					createdAt: (0, _mastra_core_storage.ensureDate)(message.createdAt),
+					type: message.type || "v2",
+					_index: index
+				};
+			}).filter((m) => !!m);
+			const messageMigrationTasks = [];
+			for (const message of validatedMessages) {
+				const existingMessage = await this.findMessageInAnyThread(message.id);
+				this.logger?.debug(`Checking message ${message.id}: existing=${existingMessage?.threadId}, new=${message.threadId}`);
+				if (existingMessage && existingMessage.threadId && existingMessage.threadId !== message.threadId) {
+					this.logger?.debug(`Migrating message ${message.id} from ${existingMessage.threadId} to ${message.threadId}`);
+					messageMigrationTasks.push(this.migrateMessage(message.id, existingMessage.threadId, message.threadId));
+				}
+			}
+			await Promise.all(messageMigrationTasks);
+			const messagesByThread = validatedMessages.reduce((acc, message) => {
+				if (message.threadId && !acc.has(message.threadId)) acc.set(message.threadId, []);
+				if (message.threadId) acc.get(message.threadId).push(message);
+				return acc;
+			}, /* @__PURE__ */ new Map());
+			await Promise.all(Array.from(messagesByThread.entries()).map(async ([threadId, threadMessages]) => {
+				try {
+					const thread = await this.getThreadById({ threadId });
+					if (!thread) throw new Error(`Thread ${threadId} not found`);
+					await Promise.all(threadMessages.map(async (message) => {
+						const key = this.getMessageKey(threadId, message.id);
+						const { _index, ...cleanMessage } = message;
+						const serializedMessage = {
+							...cleanMessage,
+							createdAt: (0, _mastra_core_storage.serializeDate)(cleanMessage.createdAt)
+						};
+						this.logger?.debug(`Saving message ${message.id}`, { contentSummary: this.summarizeMessageContent(serializedMessage.content) });
+						await this.#db.putKV({
+							tableName: _mastra_core_storage.TABLE_MESSAGES,
+							key,
+							value: serializedMessage
+						});
+					}));
+					const orderKey = this.getThreadMessagesKey(threadId);
+					const entries = await this.updateSorting(threadMessages);
+					await this.updateSortedMessages(orderKey, entries);
+					const updatedThread = {
+						...thread,
+						updatedAt: /* @__PURE__ */ new Date()
+					};
+					await this.#db.putKV({
+						tableName: _mastra_core_storage.TABLE_THREADS,
+						key: this.#db.getKey(_mastra_core_storage.TABLE_THREADS, { id: threadId }),
+						value: updatedThread
+					});
+				} catch (error) {
+					throw new _mastra_core_error.MastraError({
+						id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "SAVE_MESSAGES", "FAILED"),
+						domain: _mastra_core_error.ErrorDomain.STORAGE,
+						category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+						details: { threadId }
+					}, error);
+				}
+			}));
+			const prepared = validatedMessages.map(({ _index, ...message }) => ({
+				...message,
+				type: message.type !== "v2" ? message.type : void 0
+			}));
+			return { messages: new _mastra_core_agent.MessageList().add(prepared, "memory").get.all.db() };
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "SAVE_MESSAGES", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY
+			}, error);
+		}
+	}
+	async getRank(orderKey, id) {
+		const index = (await this.getSortedMessages(orderKey)).findIndex((item) => item.id === id);
+		return index >= 0 ? index : null;
+	}
+	async getRange(orderKey, start, end) {
+		const order = await this.getSortedMessages(orderKey);
+		const actualStart = start < 0 ? Math.max(0, order.length + start) : start;
+		const actualEnd = end < 0 ? order.length + end : Math.min(end, order.length - 1);
+		return order.slice(actualStart, actualEnd + 1).map((item) => item.id);
+	}
+	async getLastN(orderKey, n) {
+		return this.getRange(orderKey, -n, -1);
+	}
+	async getFullOrder(orderKey) {
+		return this.getRange(orderKey, 0, -1);
+	}
+	/**
+	* Retrieves messages specified in the include array along with their surrounding context.
+	*
+	* **Performance Note**: When `threadId` is not provided in an include entry, this method
+	* must call `findMessageInAnyThread` which sequentially scans all threads in the KV store.
+	* For optimal performance, callers should provide `threadId` in include entries when known.
+	*
+	* @param include - Array of message IDs to include, optionally with context windows
+	* @param messageIds - Set to accumulate the message IDs that should be fetched
+	*/
+	_sortMessages(messages, field, direction) {
+		return messages.sort((a, b) => {
+			const isDateField = field === "createdAt" || field === "updatedAt";
+			const aVal = isDateField ? new Date(a[field]).getTime() : a[field];
+			const bVal = isDateField ? new Date(b[field]).getTime() : b[field];
+			if (aVal == null && bVal == null) return a.id.localeCompare(b.id);
+			if (aVal == null) return 1;
+			if (bVal == null) return -1;
+			if (typeof aVal === "number" && typeof bVal === "number") {
+				const cmp = direction === "ASC" ? aVal - bVal : bVal - aVal;
+				return cmp !== 0 ? cmp : a.id.localeCompare(b.id);
+			}
+			const cmp = direction === "ASC" ? String(aVal).localeCompare(String(bVal)) : String(bVal).localeCompare(String(aVal));
+			return cmp !== 0 ? cmp : a.id.localeCompare(b.id);
+		});
+	}
+	async getIncludedMessagesWithContext(include, messageIds) {
+		await Promise.all(include.map(async (item) => {
+			let targetThreadId = item.threadId;
+			if (!targetThreadId) {
+				const foundMessage = await this.findMessageInAnyThread(item.id);
+				if (!foundMessage) return;
+				targetThreadId = foundMessage.threadId;
+			}
+			if (!targetThreadId) return;
+			const threadMessagesKey = this.getThreadMessagesKey(targetThreadId);
+			messageIds.add(item.id);
+			if (!item.withPreviousMessages && !item.withNextMessages) return;
+			const rank = await this.getRank(threadMessagesKey, item.id);
+			if (rank === null) return;
+			if (item.withPreviousMessages) (await this.getRange(threadMessagesKey, Math.max(0, rank - item.withPreviousMessages), rank - 1)).forEach((id) => messageIds.add(id));
+			if (item.withNextMessages) (await this.getRange(threadMessagesKey, rank + 1, rank + item.withNextMessages)).forEach((id) => messageIds.add(id));
+		}));
+	}
+	async getRecentMessages(threadId, limit, messageIds) {
+		if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
+		if (limit <= 0) return;
+		try {
+			const threadMessagesKey = this.getThreadMessagesKey(threadId);
+			(await this.getLastN(threadMessagesKey, limit)).forEach((id) => messageIds.add(id));
+		} catch {
+			this.logger?.debug(`No message order found for thread ${threadId}, skipping latest messages`);
+		}
+	}
+	/**
+	* Fetches and parses messages from one or more threads.
+	*
+	* **Performance Note**: When neither `include` entries with `threadId` nor `targetThreadId`
+	* are provided, this method falls back to `findMessageInAnyThread` which scans all threads.
+	* For optimal performance, provide `threadId` in include entries or specify `targetThreadId`.
+	*/
+	async fetchAndParseMessagesFromMultipleThreads(messageIds, include, targetThreadId) {
+		const messageIdToThreadId = /* @__PURE__ */ new Map();
+		if (include) {
+			for (const item of include) if (item.threadId) messageIdToThreadId.set(item.id, item.threadId);
+		}
+		return (await Promise.all(messageIds.map(async (id) => {
+			try {
+				let threadId = messageIdToThreadId.get(id);
+				if (!threadId) if (targetThreadId) threadId = targetThreadId;
+				else {
+					const foundMessage = await this.findMessageInAnyThread(id);
+					if (foundMessage) threadId = foundMessage.threadId;
+				}
+				if (!threadId) return null;
+				const key = this.getMessageKey(threadId, id);
+				const data = await this.#db.getKV(_mastra_core_storage.TABLE_MESSAGES, key);
+				if (!data) return null;
+				const parsed = typeof data === "string" ? JSON.parse(data) : data;
+				this.logger?.debug(`Retrieved message ${id} from thread ${threadId}`, { contentSummary: this.summarizeMessageContent(parsed.content) });
+				return parsed;
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				this.logger?.error(`Error retrieving message ${id}:`, { message });
+				return null;
+			}
+		}))).filter((msg) => msg !== null);
+	}
+	/**
+	* Retrieves messages by their IDs.
+	*
+	* **Performance Warning**: This method calls `findMessageInAnyThread` for each message ID,
+	* which scans all threads in the KV store. For large numbers of messages or threads,
+	* this can result in significant latency. Consider using `listMessages` with specific
+	* thread IDs when the thread context is known.
+	*/
+	async listMessagesById({ messageIds }) {
+		if (messageIds.length === 0) return { messages: [] };
+		try {
+			const prepared = (await Promise.all(messageIds.map((id) => this.findMessageInAnyThread(id)))).filter((result) => !!result).map(({ _index, ...message }) => ({
+				...message,
+				...message.type !== `v2` && { type: message.type },
+				createdAt: (0, _mastra_core_storage.ensureDate)(message.createdAt)
+			}));
+			return { messages: new _mastra_core_agent.MessageList().add(prepared, "memory").get.all.db() };
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "LIST_MESSAGES_BY_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Error retrieving messages by ID`,
+				details: { messageIds: JSON.stringify(messageIds) }
+			}, error);
+			this.logger?.trackException(mastraError);
+			this.logger?.error(mastraError.toString());
+			return { messages: [] };
+		}
+	}
+	async listMessages(args) {
+		const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+		const threadIds = Array.isArray(threadId) ? threadId : [threadId];
+		const isValidThreadId = (id) => typeof id === "string" && id.trim().length > 0;
+		if (threadIds.length === 0 || threadIds.some((id) => !isValidThreadId(id))) throw new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "LIST_MESSAGES", "INVALID_THREAD_ID"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+			details: { threadId: Array.isArray(threadId) ? JSON.stringify(threadId) : String(threadId) }
+		}, /* @__PURE__ */ new Error("threadId must be a non-empty string or array of non-empty strings"));
+		const perPage = (0, _mastra_core_storage.normalizePerPage)(perPageInput, 40);
+		const { offset, perPage: perPageForResponse } = (0, _mastra_core_storage.calculatePagination)(page, perPageInput, perPage);
+		const metadataFilter = (0, _mastra_core_storage.validateStorageMetadataFilter)(filter?.metadata);
+		try {
+			if (page < 0) throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "LIST_MESSAGES", "INVALID_PAGE"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.USER,
+				details: { page }
+			}, /* @__PURE__ */ new Error("page must be >= 0"));
+			const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+			if (perPage === 0 && include && include.length > 0) {
+				const includedMessageIds = /* @__PURE__ */ new Set();
+				await this.getIncludedMessagesWithContext(include, includedMessageIds);
+				const includedMessages = await this.fetchAndParseMessagesFromMultipleThreads(Array.from(includedMessageIds), include, void 0);
+				const list = new _mastra_core_agent.MessageList().add(includedMessages, "memory");
+				return {
+					messages: this._sortMessages(list.get.all.db(), field, direction),
+					total: 0,
+					page,
+					perPage: perPageForResponse,
+					hasMore: false
+				};
+			}
+			if (perPage === 0 && (!include || include.length === 0)) return {
+				messages: [],
+				total: 0,
+				page,
+				perPage: perPageForResponse,
+				hasMore: false
+			};
+			const threadMessageIds = /* @__PURE__ */ new Set();
+			for (const tid of threadIds) try {
+				const threadMessagesKey = this.getThreadMessagesKey(tid);
+				(await this.getFullOrder(threadMessagesKey)).forEach((id) => threadMessageIds.add(id));
+			} catch {}
+			let filteredThreadMessages = await this.fetchAndParseMessagesFromMultipleThreads(Array.from(threadMessageIds), void 0, threadIds.length === 1 ? threadIds[0] : void 0);
+			if (resourceId) filteredThreadMessages = filteredThreadMessages.filter((msg) => msg.resourceId === resourceId);
+			filteredThreadMessages = (0, _mastra_core_storage.filterByDateRange)(filteredThreadMessages, (msg) => new Date(msg.createdAt), filter?.dateRange);
+			filteredThreadMessages = filteredThreadMessages.filter((message) => (0, _mastra_core_storage.storageMessageMatchesMetadataFilter)(message.content, metadataFilter));
+			const total = filteredThreadMessages.length;
+			filteredThreadMessages.sort((a, b) => {
+				const timeA = new Date(a.createdAt).getTime();
+				const timeB = new Date(b.createdAt).getTime();
+				const timeDiff = direction === "ASC" ? timeA - timeB : timeB - timeA;
+				if (timeDiff === 0) return a.id.localeCompare(b.id);
+				return timeDiff;
+			});
+			let paginatedMessages;
+			if (perPage === 0) paginatedMessages = [];
+			else if (perPage === Number.MAX_SAFE_INTEGER) paginatedMessages = filteredThreadMessages;
+			else paginatedMessages = filteredThreadMessages.slice(offset, offset + perPage);
+			let includedMessages = [];
+			if (include && include.length > 0) {
+				const includedMessageIds = /* @__PURE__ */ new Set();
+				await this.getIncludedMessagesWithContext(include, includedMessageIds);
+				const paginatedIds = new Set(paginatedMessages.map((m) => m.id));
+				const idsToFetch = Array.from(includedMessageIds).filter((id) => !paginatedIds.has(id));
+				if (idsToFetch.length > 0) includedMessages = await this.fetchAndParseMessagesFromMultipleThreads(idsToFetch, include, void 0);
+			}
+			const seenIds = /* @__PURE__ */ new Set();
+			const allMessages = [];
+			for (const msg of paginatedMessages) if (!seenIds.has(msg.id)) {
+				allMessages.push(msg);
+				seenIds.add(msg.id);
+			}
+			for (const msg of includedMessages) if (!seenIds.has(msg.id)) {
+				allMessages.push(msg);
+				seenIds.add(msg.id);
+			}
+			allMessages.sort((a, b) => {
+				const timeA = new Date(a.createdAt).getTime();
+				const timeB = new Date(b.createdAt).getTime();
+				const timeDiff = direction === "ASC" ? timeA - timeB : timeB - timeA;
+				if (timeDiff === 0) return a.id.localeCompare(b.id);
+				return timeDiff;
+			});
+			let filteredMessages = allMessages;
+			const paginatedCount = paginatedMessages.length;
+			if (total === 0 && filteredMessages.length === 0 && (!include || include.length === 0)) return {
+				messages: [],
+				total: 0,
+				page,
+				perPage: perPageForResponse,
+				hasMore: false
+			};
+			const prepared = filteredMessages.map(({ _index, ...message }) => ({
+				...message,
+				type: message.type !== "v2" ? message.type : void 0,
+				createdAt: (0, _mastra_core_storage.ensureDate)(message.createdAt)
+			}));
+			const list = new _mastra_core_agent.MessageList({
+				threadId: Array.isArray(threadId) ? threadId[0] : threadId,
+				resourceId
+			}).add(prepared, "memory");
+			const finalMessages = this._sortMessages(list.get.all.db(), field, direction);
+			const threadIdSet = new Set(threadIds);
+			const returnedThreadMessageIds = new Set(finalMessages.filter((message) => message.threadId && threadIdSet.has(message.threadId)).map((message) => message.id));
+			return {
+				messages: finalMessages,
+				total,
+				page,
+				perPage: perPageForResponse,
+				hasMore: perPageInput !== false && (metadataFilter || returnedThreadMessageIds.size < total) && offset + paginatedCount < total
+			};
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "LIST_MESSAGES", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.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) {
+		try {
+			const { messages } = args;
+			const updatedMessages = [];
+			for (const messageUpdate of messages) {
+				const { id, content, ...otherFields } = messageUpdate;
+				const prefix = this.#db.namespacePrefix ? `${this.#db.namespacePrefix}:` : "";
+				const keyObjs = await this.#db.listKV(_mastra_core_storage.TABLE_MESSAGES, { prefix: `${prefix}${_mastra_core_storage.TABLE_MESSAGES}` });
+				let existingMessage = null;
+				let messageKey = "";
+				for (const { name: key } of keyObjs) {
+					const data = await this.#db.getKV(_mastra_core_storage.TABLE_MESSAGES, key);
+					if (data && data.id === id) {
+						existingMessage = data;
+						messageKey = key;
+						break;
+					}
+				}
+				if (!existingMessage) continue;
+				const updatedMessage = {
+					...existingMessage,
+					...otherFields,
+					id
+				};
+				if (content) {
+					if (content.metadata !== void 0) updatedMessage.content = {
+						...updatedMessage.content,
+						metadata: {
+							...updatedMessage.content?.metadata,
+							...content.metadata
+						}
+					};
+					if (content.content !== void 0) updatedMessage.content = {
+						...updatedMessage.content,
+						content: content.content
+					};
+				}
+				if ("threadId" in messageUpdate && messageUpdate.threadId && messageUpdate.threadId !== existingMessage.threadId) {
+					await this.#db.deleteKV(_mastra_core_storage.TABLE_MESSAGES, messageKey);
+					updatedMessage.threadId = messageUpdate.threadId;
+					const newMessageKey = this.getMessageKey(messageUpdate.threadId, id);
+					await this.#db.putKV({
+						tableName: _mastra_core_storage.TABLE_MESSAGES,
+						key: newMessageKey,
+						value: updatedMessage
+					});
+					if (existingMessage.threadId) {
+						const sourceOrderKey = this.getThreadMessagesKey(existingMessage.threadId);
+						const filteredEntries = (await this.getSortedMessages(sourceOrderKey)).filter((entry) => entry.id !== id);
+						await this.updateSortedMessages(sourceOrderKey, filteredEntries);
+					}
+					const destOrderKey = this.getThreadMessagesKey(messageUpdate.threadId);
+					const destEntries = await this.getSortedMessages(destOrderKey);
+					const newEntry = {
+						id,
+						score: Date.now()
+					};
+					destEntries.push(newEntry);
+					await this.updateSortedMessages(destOrderKey, destEntries);
+				} else await this.#db.putKV({
+					tableName: _mastra_core_storage.TABLE_MESSAGES,
+					key: messageKey,
+					value: updatedMessage
+				});
+				const threadsToUpdate = /* @__PURE__ */ new Set();
+				if (updatedMessage.threadId) threadsToUpdate.add(updatedMessage.threadId);
+				if ("threadId" in messageUpdate && messageUpdate.threadId && messageUpdate.threadId !== existingMessage.threadId) {
+					if (existingMessage.threadId) threadsToUpdate.add(existingMessage.threadId);
+					threadsToUpdate.add(messageUpdate.threadId);
+				}
+				for (const threadId of threadsToUpdate) {
+					const thread = await this.getThreadById({ threadId });
+					if (thread) {
+						const updatedThread = {
+							...thread,
+							updatedAt: /* @__PURE__ */ new Date()
+						};
+						await this.#db.putKV({
+							tableName: _mastra_core_storage.TABLE_THREADS,
+							key: this.#db.getKey(_mastra_core_storage.TABLE_THREADS, { id: threadId }),
+							value: updatedThread
+						});
+					}
+				}
+				updatedMessages.push(updatedMessage);
+			}
+			return updatedMessages;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "UPDATE_MESSAGES", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: "Failed to update messages"
+			}, error);
+		}
+	}
+	async getResourceById({ resourceId }) {
+		try {
+			const data = await this.#db.getKV(_mastra_core_storage.TABLE_RESOURCES, resourceId);
+			if (!data) return null;
+			const resource = typeof data === "string" ? JSON.parse(data) : data;
+			return {
+				...resource,
+				createdAt: (0, _mastra_core_storage.ensureDate)(resource.createdAt),
+				updatedAt: (0, _mastra_core_storage.ensureDate)(resource.updatedAt),
+				metadata: this.ensureMetadata(resource.metadata)
+			};
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "GET_RESOURCE_BY_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { resourceId }
+			}, error);
+			this.logger?.trackException(mastraError);
+			this.logger?.error(mastraError.toString());
+			return null;
+		}
+	}
+	async saveResource({ resource }) {
+		try {
+			const resourceToSave = {
+				...resource,
+				metadata: resource.metadata ? JSON.stringify(resource.metadata) : null
+			};
+			await this.#db.putKV({
+				tableName: _mastra_core_storage.TABLE_RESOURCES,
+				key: resource.id,
+				value: resourceToSave
+			});
+			return resource;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "SAVE_RESOURCE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				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
+		};
+		return this.saveResource({ resource: updatedResource });
+	}
+	async deleteMessages(messageIds) {
+		if (messageIds.length === 0) return;
+		try {
+			const threadIds = /* @__PURE__ */ new Set();
+			for (const messageId of messageIds) {
+				const message = await this.findMessageInAnyThread(messageId);
+				if (message?.threadId) {
+					threadIds.add(message.threadId);
+					const messageKey = this.getMessageKey(message.threadId, messageId);
+					await this.#db.deleteKV(_mastra_core_storage.TABLE_MESSAGES, messageKey);
+					const orderKey = this.getThreadMessagesKey(message.threadId);
+					const filteredEntries = (await this.getSortedMessages(orderKey)).filter((entry) => entry.id !== messageId);
+					if (filteredEntries.length > 0) await this.#db.putKV({
+						tableName: _mastra_core_storage.TABLE_MESSAGES,
+						key: orderKey,
+						value: JSON.stringify(filteredEntries)
+					});
+					else await this.#db.deleteKV(_mastra_core_storage.TABLE_MESSAGES, orderKey);
+				}
+			}
+			for (const threadId of threadIds) {
+				const thread = await this.getThreadById({ threadId });
+				if (thread) {
+					const updatedThread = {
+						...thread,
+						updatedAt: /* @__PURE__ */ new Date()
+					};
+					await this.#db.putKV({
+						tableName: _mastra_core_storage.TABLE_THREADS,
+						key: this.#db.getKey(_mastra_core_storage.TABLE_THREADS, { id: threadId }),
+						value: updatedThread
+					});
+				}
+			}
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "DELETE_MESSAGES", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { messageIds: JSON.stringify(messageIds) }
+			}, error);
+		}
+	}
+};
+//#endregion
+//#region src/kv/storage/domains/scores/index.ts
+/**
+* Cloudflare KV-specific score row transformation.
+* Uses default options (no timestamp conversion).
+*/
+function transformScoreRow(row) {
+	return (0, _mastra_core_storage.transformScoreRow)(row);
+}
+/** Returns true when a raw score record matches the multi-tenant scope filters (or none provided). */
+function matchesTenancy(score, filters) {
+	if (filters?.organizationId !== void 0 && score.organizationId !== filters.organizationId) return false;
+	if (filters?.projectId !== void 0 && score.projectId !== filters.projectId) return false;
+	return true;
+}
+var ScoresStorageCloudflare = class extends _mastra_core_storage.ScoresStorage {
+	#db;
+	constructor(config) {
+		super();
+		this.#db = new CloudflareKVDB(resolveCloudflareConfig(config));
+	}
+	async init() {}
+	async dangerouslyClearAll() {
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_SCORERS });
+	}
+	async getScoreById({ id }) {
+		try {
+			const score = await this.#db.getKV(_mastra_core_storage.TABLE_SCORERS, id);
+			if (!score) return null;
+			return transformScoreRow(score);
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "GET_SCORE_BY_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to get score by id: ${id}`
+			}, error);
+			this.logger?.trackException(mastraError);
+			this.logger?.error(mastraError.toString());
+			return null;
+		}
+	}
+	async saveScore(score) {
+		let parsedScore;
+		try {
+			parsedScore = _mastra_core_evals.saveScorePayloadSchema.parse(score);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "SAVE_SCORE", "VALIDATION_FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.USER,
+				details: {
+					scorer: typeof score.scorer?.id === "string" ? score.scorer.id : String(score.scorer?.id ?? "unknown"),
+					entityId: score.entityId ?? "unknown",
+					entityType: score.entityType ?? "unknown",
+					traceId: score.traceId ?? "",
+					spanId: score.spanId ?? ""
+				}
+			}, error);
+		}
+		const id = crypto.randomUUID();
+		try {
+			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();
+			await this.#db.putKV({
+				tableName: _mastra_core_storage.TABLE_SCORERS,
+				key: id,
+				value: serializedRecord
+			});
+			return { score: {
+				...parsedScore,
+				id,
+				createdAt: now,
+				updatedAt: now
+			} };
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "SAVE_SCORE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { id }
+			}, error);
+			this.logger?.trackException(mastraError);
+			this.logger?.error(mastraError.toString());
+			throw mastraError;
+		}
+	}
+	async listScoresByScorerId({ scorerId, entityId, entityType, source, pagination, filters }) {
+		try {
+			const keys = await this.#db.listKV(_mastra_core_storage.TABLE_SCORERS);
+			const scores = [];
+			for (const { name: key } of keys) {
+				const score = await this.#db.getKV(_mastra_core_storage.TABLE_SCORERS, key);
+				if (entityId && score.entityId !== entityId) continue;
+				if (entityType && score.entityType !== entityType) continue;
+				if (source && score.source !== source) continue;
+				if (!matchesTenancy(score, filters)) continue;
+				if (score && score.scorerId === scorerId) scores.push(transformScoreRow(score));
+			}
+			scores.sort((a, b) => {
+				const dateA = new Date(a.createdAt || 0).getTime();
+				return new Date(b.createdAt || 0).getTime() - dateA;
+			});
+			const { page, perPage: perPageInput } = pagination;
+			const perPage = (0, _mastra_core_storage.normalizePerPage)(perPageInput, 100);
+			const { offset: start, perPage: perPageForResponse } = (0, _mastra_core_storage.calculatePagination)(page, perPageInput, perPage);
+			const total = scores.length;
+			const end = perPageInput === false ? scores.length : start + perPage;
+			const pagedScores = scores.slice(start, end);
+			return {
+				pagination: {
+					total,
+					page,
+					perPage: perPageForResponse,
+					hasMore: end < total
+				},
+				scores: pagedScores
+			};
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "GET_SCORES_BY_SCORER_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to get scores by scorer id: ${scorerId}`
+			}, error);
+			this.logger?.trackException(mastraError);
+			this.logger?.error(mastraError.toString());
+			return {
+				pagination: {
+					total: 0,
+					page: 0,
+					perPage: 100,
+					hasMore: false
+				},
+				scores: []
+			};
+		}
+	}
+	async listScoresByRunId({ runId, pagination, filters }) {
+		try {
+			const keys = await this.#db.listKV(_mastra_core_storage.TABLE_SCORERS);
+			const scores = [];
+			for (const { name: key } of keys) {
+				const score = await this.#db.getKV(_mastra_core_storage.TABLE_SCORERS, key);
+				if (score && score.runId === runId && matchesTenancy(score, filters)) scores.push(transformScoreRow(score));
+			}
+			scores.sort((a, b) => {
+				const dateA = new Date(a.createdAt || 0).getTime();
+				return new Date(b.createdAt || 0).getTime() - dateA;
+			});
+			const { page, perPage: perPageInput } = pagination;
+			const perPage = (0, _mastra_core_storage.normalizePerPage)(perPageInput, 100);
+			const { offset: start, perPage: perPageForResponse } = (0, _mastra_core_storage.calculatePagination)(page, perPageInput, perPage);
+			const total = scores.length;
+			const end = perPageInput === false ? scores.length : start + perPage;
+			const pagedScores = scores.slice(start, end);
+			return {
+				pagination: {
+					total,
+					page,
+					perPage: perPageForResponse,
+					hasMore: end < total
+				},
+				scores: pagedScores
+			};
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "GET_SCORES_BY_RUN_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to get scores by run id: ${runId}`
+			}, error);
+			this.logger?.trackException(mastraError);
+			this.logger?.error(mastraError.toString());
+			return {
+				pagination: {
+					total: 0,
+					page: 0,
+					perPage: 100,
+					hasMore: false
+				},
+				scores: []
+			};
+		}
+	}
+	async listScoresByEntityId({ entityId, entityType, pagination, filters }) {
+		try {
+			const keys = await this.#db.listKV(_mastra_core_storage.TABLE_SCORERS);
+			const scores = [];
+			for (const { name: key } of keys) {
+				const score = await this.#db.getKV(_mastra_core_storage.TABLE_SCORERS, key);
+				if (score && score.entityId === entityId && score.entityType === entityType && matchesTenancy(score, filters)) scores.push(transformScoreRow(score));
+			}
+			scores.sort((a, b) => {
+				const dateA = new Date(a.createdAt || 0).getTime();
+				return new Date(b.createdAt || 0).getTime() - dateA;
+			});
+			const { page, perPage: perPageInput } = pagination;
+			const perPage = (0, _mastra_core_storage.normalizePerPage)(perPageInput, 100);
+			const { offset: start, perPage: perPageForResponse } = (0, _mastra_core_storage.calculatePagination)(page, perPageInput, perPage);
+			const total = scores.length;
+			const end = perPageInput === false ? scores.length : start + perPage;
+			const pagedScores = scores.slice(start, end);
+			return {
+				pagination: {
+					total,
+					page,
+					perPage: perPageForResponse,
+					hasMore: end < total
+				},
+				scores: pagedScores
+			};
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "GET_SCORES_BY_ENTITY_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to get scores by entity id: ${entityId}, type: ${entityType}`
+			}, error);
+			this.logger?.trackException(mastraError);
+			this.logger?.error(mastraError.toString());
+			return {
+				pagination: {
+					total: 0,
+					page: 0,
+					perPage: 100,
+					hasMore: false
+				},
+				scores: []
+			};
+		}
+	}
+	async listScoresBySpan({ traceId, spanId, pagination, filters }) {
+		try {
+			const keys = await this.#db.listKV(_mastra_core_storage.TABLE_SCORERS);
+			const scores = [];
+			for (const { name: key } of keys) {
+				const score = await this.#db.getKV(_mastra_core_storage.TABLE_SCORERS, key);
+				if (score && score.traceId === traceId && score.spanId === spanId && matchesTenancy(score, filters)) scores.push(transformScoreRow(score));
+			}
+			scores.sort((a, b) => {
+				const dateA = new Date(a.createdAt || 0).getTime();
+				return new Date(b.createdAt || 0).getTime() - dateA;
+			});
+			const { page, perPage: perPageInput } = pagination;
+			const perPage = (0, _mastra_core_storage.normalizePerPage)(perPageInput, 100);
+			const { offset: start, perPage: perPageForResponse } = (0, _mastra_core_storage.calculatePagination)(page, perPageInput, perPage);
+			const total = scores.length;
+			const end = perPageInput === false ? scores.length : start + perPage;
+			const pagedScores = scores.slice(start, end);
+			return {
+				pagination: {
+					total,
+					page,
+					perPage: perPageForResponse,
+					hasMore: end < total
+				},
+				scores: pagedScores
+			};
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "GET_SCORES_BY_SPAN", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Failed to get scores by span: traceId=${traceId}, spanId=${spanId}`
+			}, error);
+			this.logger?.trackException(mastraError);
+			this.logger?.error(mastraError.toString());
+			return {
+				pagination: {
+					total: 0,
+					page: 0,
+					perPage: 100,
+					hasMore: false
+				},
+				scores: []
+			};
+		}
+	}
+};
+//#endregion
+//#region src/kv/storage/domains/workflows/index.ts
+var WorkflowsStorageCloudflare = class extends _mastra_core_storage.WorkflowsStorage {
+	#db;
+	constructor(config) {
+		super();
+		this.#db = new CloudflareKVDB(resolveCloudflareConfig(config));
+	}
+	supportsConcurrentUpdates() {
+		return false;
+	}
+	async init() {}
+	async dangerouslyClearAll() {
+		await this.#db.clearTable({ tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT });
+	}
+	validateWorkflowParams(params) {
+		const { workflowName, runId } = params;
+		if (!workflowName || !runId) throw new Error("Invalid workflow snapshot parameters");
+	}
+	async updateWorkflowResults(_args) {
+		throw new Error("updateWorkflowResults is not implemented for Cloudflare KV storage. Cloudflare KV is eventually-consistent and does not support atomic read-modify-write operations needed for concurrent workflow updates.");
+	}
+	async updateWorkflowState(_args) {
+		throw new Error("updateWorkflowState is not implemented for Cloudflare KV storage. Cloudflare KV is eventually-consistent and does not support atomic read-modify-write operations needed for concurrent workflow updates.");
+	}
+	async persistWorkflowSnapshot(params) {
+		try {
+			const { workflowName, runId, resourceId, snapshot, createdAt, updatedAt } = params;
+			const now = /* @__PURE__ */ new Date();
+			const existingKey = this.#db.getKey(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, {
+				workflow_name: workflowName,
+				run_id: runId
+			});
+			const existing = await this.#db.getKV(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, existingKey);
+			await this.#db.putKV({
+				tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+				key: existingKey,
+				value: {
+					workflow_name: workflowName,
+					run_id: runId,
+					resourceId,
+					snapshot: JSON.stringify(snapshot),
+					createdAt: existing?.createdAt ?? createdAt ?? now,
+					updatedAt: updatedAt ?? now
+				}
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Error persisting workflow snapshot for workflow ${params.workflowName}, run ${params.runId}`,
+				details: {
+					workflowName: params.workflowName,
+					runId: params.runId
+				}
+			}, error);
+		}
+	}
+	async loadWorkflowSnapshot(params) {
+		try {
+			this.validateWorkflowParams(params);
+			const { workflowName, runId } = params;
+			const key = this.#db.getKey(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, {
+				workflow_name: workflowName,
+				run_id: runId
+			});
+			const data = await this.#db.getKV(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, key);
+			if (!data) return null;
+			return typeof data.snapshot === "string" ? JSON.parse(data.snapshot) : data.snapshot;
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "LOAD_WORKFLOW_SNAPSHOT", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				text: `Error loading workflow snapshot for workflow ${params.workflowName}, run ${params.runId}`,
+				details: {
+					workflowName: params.workflowName,
+					runId: params.runId
+				}
+			}, error);
+			this.logger.trackException?.(mastraError);
+			this.logger.error(mastraError.toString());
+			return null;
+		}
+	}
+	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: (0, _mastra_core_storage.ensureDate)(row.createdAt),
+			updatedAt: (0, _mastra_core_storage.ensureDate)(row.updatedAt),
+			resourceId: row.resourceId
+		};
+	}
+	buildWorkflowSnapshotPrefix({ workflowName, runId, resourceId }) {
+		let key = `${this.#db.namespacePrefix ? `${this.#db.namespacePrefix}:` : ""}${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT}`;
+		if (workflowName) key += `:${workflowName}`;
+		if (runId) key += `:${runId}`;
+		if (resourceId) key += `:${resourceId}`;
+		return key;
+	}
+	async listWorkflowRuns({ workflowName, page = 0, perPage = 20, resourceId, fromDate, toDate, status } = {}) {
+		try {
+			if (page < 0 || !Number.isInteger(page)) throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "LIST_WORKFLOW_RUNS", "INVALID_PAGE"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.USER,
+				details: { page }
+			}, /* @__PURE__ */ new Error("page must be a non-negative integer"));
+			const normalizedPerPage = (0, _mastra_core_storage.normalizePerPage)(perPage, 20);
+			const offset = page * normalizedPerPage;
+			const prefix = this.buildWorkflowSnapshotPrefix({ workflowName });
+			const keyObjs = await this.#db.listKV(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, { prefix });
+			const runs = [];
+			for (const { name: key } of keyObjs) {
+				const parts = key.split(":");
+				const idx = parts.indexOf(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
+				if (idx === -1 || parts.length < idx + 3) continue;
+				const wfName = parts[idx + 1];
+				const keyResourceId = parts.length > idx + 3 ? parts[idx + 3] : void 0;
+				if (workflowName && wfName !== workflowName) continue;
+				const data = await this.#db.getKV(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, key);
+				if (!data) continue;
+				try {
+					const effectiveResourceId = keyResourceId || data.resourceId;
+					if (resourceId && effectiveResourceId !== resourceId) continue;
+					const snapshotData = typeof data.snapshot === "string" ? JSON.parse(data.snapshot) : data.snapshot;
+					if (status && snapshotData.status !== status) continue;
+					const createdAt = (0, _mastra_core_storage.ensureDate)(data.createdAt);
+					if (fromDate && createdAt && createdAt < fromDate) continue;
+					if (toDate && createdAt && createdAt > toDate) continue;
+					const run = this.parseWorkflowRun({
+						...data,
+						workflow_name: wfName,
+						resourceId: effectiveResourceId,
+						snapshot: snapshotData
+					});
+					runs.push(run);
+				} catch (err) {
+					this.logger.error("Failed to parse workflow snapshot:", {
+						key,
+						error: err
+					});
+				}
+			}
+			runs.sort((a, b) => {
+				const aDate = a.createdAt ? new Date(a.createdAt).getTime() : 0;
+				return (b.createdAt ? new Date(b.createdAt).getTime() : 0) - aDate;
+			});
+			return {
+				runs: runs.slice(offset, offset + normalizedPerPage),
+				total: runs.length
+			};
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "LIST_WORKFLOW_RUNS", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY
+			}, error);
+			this.logger.trackException?.(mastraError);
+			this.logger.error(mastraError.toString());
+			return {
+				runs: [],
+				total: 0
+			};
+		}
+	}
+	async getWorkflowRunById({ runId, workflowName }) {
+		try {
+			if (!runId || !workflowName) throw new Error("runId, workflowName, are required");
+			const prefix = this.buildWorkflowSnapshotPrefix({
+				workflowName,
+				runId
+			});
+			const keyObjs = await this.#db.listKV(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, { prefix });
+			if (!keyObjs.length) return null;
+			const exactKey = keyObjs.find((k) => {
+				const parts = k.name.split(":");
+				const idx = parts.indexOf(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
+				if (idx === -1 || parts.length < idx + 3) return false;
+				const wfName = parts[idx + 1];
+				const rId = parts[idx + 2];
+				return wfName === workflowName && rId === runId;
+			});
+			if (!exactKey) return null;
+			const data = await this.#db.getKV(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, exactKey.name);
+			if (!data) return null;
+			const snapshotData = typeof data.snapshot === "string" ? JSON.parse(data.snapshot) : data.snapshot;
+			return this.parseWorkflowRun({
+				...data,
+				snapshot: snapshotData
+			});
+		} catch (error) {
+			const mastraError = new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					workflowName,
+					runId
+				}
+			}, error);
+			this.logger.trackException?.(mastraError);
+			this.logger.error(mastraError.toString());
+			return null;
+		}
+	}
+	async deleteWorkflowRunById({ runId, workflowName }) {
+		try {
+			if (!runId || !workflowName) throw new Error("runId and workflowName are required");
+			const key = this.#db.getKey(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, {
+				workflow_name: workflowName,
+				run_id: runId
+			});
+			await this.#db.deleteKV(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, key);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					workflowName,
+					runId
+				}
+			}, error);
+		}
+	}
+};
+//#endregion
+//#region src/kv/storage/types.ts
+/**
+* Helper to determine if a config is using Workers bindings
+*/
+function isWorkersConfig(config) {
+	return "bindings" in config;
+}
+//#endregion
+//#region src/kv/index.ts
+/**
+* Cloudflare KV storage adapter for Mastra.
+*
+* Access domain-specific storage via `getStore()`:
+*
+* @example
+* ```typescript
+* const storage = new CloudflareKVStorage({ id: 'my-store', accountId: '...', apiToken: '...' });
+*
+* // Access memory domain
+* const memory = await storage.getStore('memory');
+* await memory?.saveThread({ thread });
+*
+* // Access workflows domain
+* const workflows = await storage.getStore('workflows');
+* await workflows?.persistWorkflowSnapshot({ workflowName, runId, snapshot });
+* ```
+*/
+var CloudflareKVStorage = class extends _mastra_core_storage.MastraCompositeStore {
+	stores;
+	client;
+	accountId;
+	namespacePrefix;
+	bindings;
+	validateWorkersConfig(config) {
+		if (!isWorkersConfig(config)) throw new Error("Invalid Workers API configuration");
+		if (!config.bindings) throw new Error("KV bindings are required when using Workers Binding API");
+		const requiredTables = [
+			_mastra_core_storage.TABLE_THREADS,
+			_mastra_core_storage.TABLE_MESSAGES,
+			_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+			_mastra_core_storage.TABLE_SCORERS,
+			_mastra_core_storage.TABLE_BACKGROUND_TASKS
+		];
+		for (const table of requiredTables) if (!(table in config.bindings)) throw new Error(`Missing KV binding for table: ${table}`);
+	}
+	validateRestConfig(config) {
+		if (isWorkersConfig(config)) throw new Error("Invalid REST API configuration");
+		if (!config.accountId?.trim()) throw new Error("accountId is required for REST API");
+		if (!config.apiToken?.trim()) throw new Error("apiToken is required for REST API");
+	}
+	constructor(config) {
+		super({
+			id: config.id,
+			name: "Cloudflare",
+			disableInit: config.disableInit
+		});
+		try {
+			let workflows;
+			let memory;
+			let scores;
+			let backgroundTasks;
+			if (isWorkersConfig(config)) {
+				this.validateWorkersConfig(config);
+				this.bindings = config.bindings;
+				this.namespacePrefix = config.keyPrefix?.trim() || "";
+				this.logger.info("Using Cloudflare KV Workers Binding API");
+				const domainConfig = {
+					bindings: this.bindings,
+					keyPrefix: this.namespacePrefix
+				};
+				workflows = new WorkflowsStorageCloudflare(domainConfig);
+				memory = new MemoryStorageCloudflare(domainConfig);
+				scores = new ScoresStorageCloudflare(domainConfig);
+				backgroundTasks = new BackgroundTasksStorageCloudflare(domainConfig);
+			} else {
+				this.validateRestConfig(config);
+				this.accountId = config.accountId.trim();
+				this.namespacePrefix = config.namespacePrefix?.trim() || "";
+				this.client = new cloudflare.default({ apiToken: config.apiToken.trim() });
+				this.logger.info("Using Cloudflare KV REST API");
+				const domainConfig = {
+					client: this.client,
+					accountId: this.accountId,
+					namespacePrefix: this.namespacePrefix
+				};
+				workflows = new WorkflowsStorageCloudflare(domainConfig);
+				memory = new MemoryStorageCloudflare(domainConfig);
+				scores = new ScoresStorageCloudflare(domainConfig);
+				backgroundTasks = new BackgroundTasksStorageCloudflare(domainConfig);
+			}
+			this.stores = {
+				workflows,
+				memory,
+				scores,
+				backgroundTasks
+			};
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("CLOUDFLARE", "INIT", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY
+			}, error);
+		}
+	}
+	async close() {}
+};
+/**
+* @deprecated Use CloudflareKVStorage instead
+*/
+const CloudflareStore = CloudflareKVStorage;
+//#endregion
+Object.defineProperty(exports, "BackgroundTasksStorageCloudflare", {
+	enumerable: true,
+	get: function() {
+		return BackgroundTasksStorageCloudflare;
+	}
+});
+Object.defineProperty(exports, "CloudflareKVStorage", {
+	enumerable: true,
+	get: function() {
+		return CloudflareKVStorage;
+	}
+});
+Object.defineProperty(exports, "CloudflareStore", {
+	enumerable: true,
+	get: function() {
+		return CloudflareStore;
+	}
+});
+Object.defineProperty(exports, "MemoryStorageCloudflare", {
+	enumerable: true,
+	get: function() {
+		return MemoryStorageCloudflare;
+	}
+});
+Object.defineProperty(exports, "ScoresStorageCloudflare", {
+	enumerable: true,
+	get: function() {
+		return ScoresStorageCloudflare;
+	}
+});
+Object.defineProperty(exports, "WorkflowsStorageCloudflare", {
+	enumerable: true,
+	get: function() {
+		return WorkflowsStorageCloudflare;
+	}
+});
+
+//# sourceMappingURL=kv-DAbAqe-v.cjs.map