@mastra/valkey 0.0.0 → 0.2.0

package/dist/index.js

@@ -0,0 +1,1758 @@
+import { MessageList } from "@mastra/core/agent";
+import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
+import { MastraStorage, MemoryStorage, ScoresStorage, TABLE_MESSAGES, TABLE_RESOURCES, TABLE_SCORERS, TABLE_THREADS, TABLE_WORKFLOW_SNAPSHOT, WorkflowsStorage, calculatePagination, createStorageErrorId, ensureDate, filterByDateRange, jsonValueEquals, matchesExpectedWorkflowStatus, normalizePerPage, serializeDate, storageMessageMatchesMetadataFilter, transformScoreRow, validateStorageMetadataFilter } from "@mastra/core/storage";
+import crypto$1 from "crypto";
+import { saveScorePayloadSchema } from "@mastra/core/evals";
+import { Batch, Decoder, GlideClient } from "@valkey/valkey-glide";
+import { MastraServerCache } from "@mastra/core/cache";
+//#region src/storage/domains/utils.ts
+/**
+* Generate a Valkey key from table name and key parts.
+*
+* @example
+* ```typescript
+* getKey('mastra_threads', { id: 'thread-123' });
+* // Returns: 'mastra_threads:id:thread-123'
+*
+* getKey('mastra_messages', { threadId: 'thread-123', id: 'msg-456' });
+* // Returns: 'mastra_messages:threadId:thread-123:id:msg-456'
+* ```
+*/
+function getKey(tableName, keys) {
+	return `${tableName}:${Object.entries(keys).filter(([_, value]) => value !== void 0).map(([key, value]) => {
+		if (value && typeof value === "object") return `${key}:${JSON.stringify(value)}`;
+		return `${key}:${value}`;
+	}).join(":")}`;
+}
+/**
+* Process a record for storage, generating the appropriate key and serializing dates.
+*/
+function processRecord(tableName, record) {
+	let key;
+	if (tableName === TABLE_MESSAGES) key = getKey(tableName, {
+		threadId: record.threadId,
+		id: record.id
+	});
+	else if (tableName === TABLE_WORKFLOW_SNAPSHOT) key = getKey(tableName, {
+		namespace: record.namespace || "workflows",
+		workflow_name: record.workflow_name,
+		run_id: record.run_id,
+		...record.resourceId ? { resourceId: record.resourceId } : {}
+	});
+	else key = getKey(tableName, { id: record.id });
+	const processedRecord = {
+		...record,
+		createdAt: serializeDate(record.createdAt),
+		updatedAt: serializeDate(record.updatedAt)
+	};
+	return {
+		key,
+		processedRecord
+	};
+}
+//#endregion
+//#region src/storage/db/index.ts
+var ValkeyDB = class {
+	client;
+	constructor({ client }) {
+		this.client = client;
+	}
+	getClient() {
+		return this.client;
+	}
+	async insert({ tableName, record }) {
+		const { key, processedRecord } = processRecord(tableName, record);
+		try {
+			await this.client.set(key, JSON.stringify(processedRecord));
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "INSERT", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async get({ tableName, keys }) {
+		const key = getKey(tableName, keys);
+		try {
+			const data = await this.client.get(key);
+			if (!data) return null;
+			return JSON.parse(data);
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "LOAD", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async scanAndDelete(pattern, batchSize = 1e4) {
+		let cursor = "0";
+		let totalDeleted = 0;
+		do {
+			const result = await this.client.scan(cursor, {
+				MATCH: pattern,
+				COUNT: batchSize
+			});
+			if (result.keys.length > 0) {
+				await this.client.del(result.keys);
+				totalDeleted += result.keys.length;
+			}
+			cursor = result.cursor;
+		} while (cursor !== "0");
+		return totalDeleted;
+	}
+	async scanKeys(pattern, batchSize = 1e4) {
+		let cursor = "0";
+		const keys = [];
+		do {
+			const result = await this.client.scan(cursor, {
+				MATCH: pattern,
+				COUNT: batchSize
+			});
+			keys.push(...result.keys);
+			cursor = result.cursor;
+		} while (cursor !== "0");
+		return keys;
+	}
+	async deleteData({ tableName }) {
+		const pattern = `${tableName}:*`;
+		try {
+			await this.scanAndDelete(pattern);
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "CLEAR_TABLE", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+};
+//#endregion
+//#region src/storage/domains/memory/index.ts
+var StoreMemoryValkey = class extends MemoryStorage {
+	supportsPartialThreadUpdate = true;
+	client;
+	db;
+	constructor(config) {
+		super();
+		this.client = config.client;
+		this.db = new ValkeyDB({ client: config.client });
+	}
+	async dangerouslyClearAll() {
+		await this.db.deleteData({ tableName: TABLE_THREADS });
+		await this.db.deleteData({ tableName: TABLE_MESSAGES });
+		await this.db.deleteData({ tableName: TABLE_RESOURCES });
+		await this.db.scanAndDelete("msg-idx:*");
+		await this.db.scanAndDelete("thread:*:messages");
+	}
+	async getThreadById({ threadId, resourceId }) {
+		try {
+			const thread = await this.db.get({
+				tableName: TABLE_THREADS,
+				keys: { id: threadId }
+			});
+			if (!thread || resourceId !== void 0 && thread.resourceId !== resourceId) return null;
+			return {
+				...thread,
+				createdAt: ensureDate(thread.createdAt),
+				updatedAt: ensureDate(thread.updatedAt),
+				metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
+			};
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "GET_THREAD_BY_ID", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { threadId }
+			}, error);
+		}
+	}
+	async listThreadsByResourceId(args) {
+		return this.listThreads(args);
+	}
+	async listThreads(args) {
+		const { page = 0, perPage: perPageInput, orderBy, filter } = args;
+		const { field, direction } = this.parseOrderBy(orderBy);
+		try {
+			this.validatePaginationInput(page, perPageInput ?? 100);
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "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("VALKEY", "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);
+		try {
+			let allThreads = [];
+			const pattern = `${TABLE_THREADS}:*`;
+			const keys = await this.db.scanKeys(pattern);
+			if (keys.length === 0) return {
+				threads: [],
+				total: 0,
+				page,
+				perPage: perPageForResponse,
+				hasMore: false
+			};
+			const results = await this.client.mGet(keys);
+			for (let i = 0; i < results.length; i++) {
+				const data = results[i];
+				if (!data) continue;
+				const thread = JSON.parse(data);
+				if (filter?.resourceId && thread.resourceId !== filter.resourceId) continue;
+				if (filter?.metadata && Object.keys(filter.metadata).length > 0) {
+					const threadMetadata = typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata;
+					if (!Object.entries(filter.metadata).every(([key, value]) => jsonValueEquals(threadMetadata?.[key], value))) continue;
+				}
+				allThreads.push({
+					...thread,
+					createdAt: ensureDate(thread.createdAt),
+					updatedAt: ensureDate(thread.updatedAt),
+					metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
+				});
+			}
+			const sortedThreads = this.sortThreads(allThreads, field, direction);
+			const total = sortedThreads.length;
+			const end = perPageInput === false ? total : offset + perPage;
+			return {
+				threads: sortedThreads.slice(offset, end),
+				total,
+				page,
+				perPage: perPageForResponse,
+				hasMore: perPageInput === false ? false : end < total
+			};
+		} catch (error) {
+			if (error instanceof MastraError && error.category === ErrorCategory.USER) throw error;
+			const mastraError = new MastraError({
+				id: createStorageErrorId("VALKEY", "LIST_THREADS", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					...filter?.resourceId && { resourceId: filter.resourceId },
+					hasMetadataFilter: !!filter?.metadata,
+					page,
+					perPage
+				}
+			}, error);
+			this.logger.trackException(mastraError);
+			this.logger.error(mastraError.toString());
+			throw mastraError;
+		}
+	}
+	async saveThread({ thread }) {
+		try {
+			await this.db.insert({
+				tableName: TABLE_THREADS,
+				record: thread
+			});
+			return thread;
+		} catch (error) {
+			const mastraError = new MastraError({
+				id: createStorageErrorId("VALKEY", "SAVE_THREAD", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { threadId: thread.id }
+			}, error);
+			this.logger.trackException(mastraError);
+			this.logger.error(mastraError.toString());
+			throw mastraError;
+		}
+	}
+	async updateThread({ id, title, metadata }) {
+		const thread = await this.getThreadById({ threadId: id });
+		if (!thread) throw new MastraError({
+			id: createStorageErrorId("VALKEY", "UPDATE_THREAD", "FAILED"),
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			text: `Thread ${id} not found`,
+			details: { threadId: id }
+		});
+		const updatedThread = {
+			...thread,
+			title: title ?? thread.title,
+			metadata: {
+				...thread.metadata,
+				...metadata
+			},
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+		try {
+			await this.saveThread({ thread: updatedThread });
+			return updatedThread;
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "UPDATE_THREAD", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { threadId: id }
+			}, error);
+		}
+	}
+	async deleteThread({ threadId }) {
+		const threadKey = getKey(TABLE_THREADS, { id: threadId });
+		const threadMessagesKey = getThreadMessagesKey(threadId);
+		try {
+			const messageIds = await this.client.zRange(threadMessagesKey, 0, -1);
+			const multi = this.client.multi();
+			multi.del(threadKey);
+			multi.del(threadMessagesKey);
+			for (const messageId of messageIds) {
+				const messageKey = getMessageKey(threadId, messageId);
+				multi.del(messageKey);
+				multi.del(getMessageIndexKey(messageId));
+			}
+			await multi.exec();
+			await this.db.scanAndDelete(getMessageKey(threadId, "*"));
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "DELETE_THREAD", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { threadId }
+			}, error);
+		}
+	}
+	async saveMessages(args) {
+		const { messages } = args;
+		if (messages.length === 0) return { messages: [] };
+		const threadId = messages[0]?.threadId;
+		try {
+			if (!threadId) throw new Error("Thread ID is required");
+			if (!await this.getThreadById({ threadId })) throw new Error(`Thread ${threadId} not found`);
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "SAVE_MESSAGES", "INVALID_ARGS"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER
+			}, error);
+		}
+		const messagesWithIndex = messages.map((message, index) => {
+			if (!message.threadId) throw new Error(`Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`);
+			if (!message.resourceId) throw new Error(`Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`);
+			return {
+				...message,
+				_index: index
+			};
+		});
+		const threadKey = getKey(TABLE_THREADS, { id: threadId });
+		const existingThreadData = await this.client.get(threadKey);
+		const existingThread = existingThreadData ? JSON.parse(existingThreadData) : null;
+		try {
+			const batchSize = 1e3;
+			const existingThreadIds = await this.client.mGet(messagesWithIndex.map((message) => getMessageIndexKey(message.id)));
+			for (let i = 0; i < messagesWithIndex.length; i += batchSize) {
+				const batch = messagesWithIndex.slice(i, i + batchSize);
+				const batchExistingThreadIds = existingThreadIds.slice(i, i + batch.length);
+				const multi = this.client.multi();
+				for (const [batchIndex, message] of batch.entries()) {
+					const key = getMessageKey(message.threadId, message.id);
+					const score = getMessageScore(message);
+					const existingThreadId = batchExistingThreadIds[batchIndex];
+					if (existingThreadId && existingThreadId !== message.threadId) {
+						const existingMessageKey = getMessageKey(existingThreadId, message.id);
+						multi.del(existingMessageKey);
+						multi.zRem(getThreadMessagesKey(existingThreadId), message.id);
+					}
+					multi.set(key, JSON.stringify(message));
+					multi.set(getMessageIndexKey(message.id), message.threadId);
+					multi.zAdd(getThreadMessagesKey(message.threadId), {
+						score,
+						value: message.id
+					});
+				}
+				if (i === 0 && existingThread) {
+					const updatedThread = {
+						...existingThread,
+						updatedAt: /* @__PURE__ */ new Date()
+					};
+					multi.set(threadKey, JSON.stringify(processRecord(TABLE_THREADS, updatedThread).processedRecord));
+				}
+				await multi.exec();
+			}
+			return { messages: new MessageList().add(messages, "memory").get.all.db() };
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "SAVE_MESSAGES", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { threadId }
+			}, error);
+		}
+	}
+	async getThreadIdForMessage(messageId) {
+		const indexedThreadId = await this.client.get(getMessageIndexKey(messageId));
+		if (indexedThreadId) return indexedThreadId;
+		const keys = await this.db.scanKeys(getMessageKey("*", messageId));
+		if (keys.length === 0) return null;
+		const messageData = await this.client.get(keys[0]);
+		if (!messageData) return null;
+		const message = JSON.parse(messageData);
+		if (message.threadId) await this.client.set(getMessageIndexKey(messageId), message.threadId);
+		return message.threadId || null;
+	}
+	/**
+	* Fetches the messages named by `include` together with their surrounding context.
+	*
+	* @param include - Message ids to pin, each with an optional before/after window.
+	* @param resourceId - When set, drops any pinned or context message owned by another
+	* resource so an id from another resource returns nothing.
+	*/
+	async getIncludedMessages(include, resourceId) {
+		if (!include?.length) return [];
+		const messageIds = /* @__PURE__ */ new Set();
+		const messageIdToThreadIds = {};
+		for (const item of include) {
+			const itemThreadId = await this.getThreadIdForMessage(item.id);
+			if (!itemThreadId) continue;
+			const itemThreadMessagesKey = getThreadMessagesKey(itemThreadId);
+			if (resourceId !== void 0) {
+				const threadMessageIds = await this.client.zRange(itemThreadMessagesKey, 0, -1);
+				const threadMessages = (await this.client.mGet(threadMessageIds.map((id) => getMessageKey(itemThreadId, id)))).filter((data) => data !== null).map((data) => JSON.parse(data)).filter((message) => message.resourceId === resourceId);
+				const targetIndex = threadMessages.findIndex((message) => message.id === item.id);
+				if (targetIndex === -1) continue;
+				const start = Math.max(0, targetIndex - (item.withPreviousMessages ?? 0));
+				const end = Math.min(threadMessages.length, targetIndex + (item.withNextMessages ?? 0) + 1);
+				for (const message of threadMessages.slice(start, end)) {
+					messageIds.add(message.id);
+					messageIdToThreadIds[message.id] = itemThreadId;
+				}
+				continue;
+			}
+			messageIds.add(item.id);
+			messageIdToThreadIds[item.id] = itemThreadId;
+			const rank = await this.client.zRank(itemThreadMessagesKey, item.id);
+			if (rank === null) continue;
+			if (item.withPreviousMessages) {
+				const start = Math.max(0, rank - item.withPreviousMessages);
+				(rank === 0 ? [] : await this.client.zRange(itemThreadMessagesKey, start, rank - 1)).forEach((id) => {
+					messageIds.add(id);
+					messageIdToThreadIds[id] = itemThreadId;
+				});
+			}
+			if (item.withNextMessages) (await this.client.zRange(itemThreadMessagesKey, rank + 1, rank + item.withNextMessages)).forEach((id) => {
+				messageIds.add(id);
+				messageIdToThreadIds[id] = itemThreadId;
+			});
+		}
+		if (messageIds.size === 0) return [];
+		const keysToFetch = Array.from(messageIds).map((id) => getMessageKey(messageIdToThreadIds[id], id));
+		const includedMessages = (await this.client.mGet(keysToFetch)).filter((data) => data !== null).map((data) => JSON.parse(data));
+		return resourceId ? includedMessages.filter((message) => message.resourceId === resourceId) : includedMessages;
+	}
+	parseStoredMessage(storedMessage) {
+		const defaultMessageContent = {
+			format: 2,
+			parts: [{
+				type: "text",
+				text: ""
+			}]
+		};
+		const { _index, ...rest } = storedMessage;
+		return {
+			...rest,
+			createdAt: new Date(rest.createdAt),
+			content: rest.content || defaultMessageContent
+		};
+	}
+	async listMessagesById({ messageIds }) {
+		if (messageIds.length === 0) return { messages: [] };
+		try {
+			const rawMessages = [];
+			const indexKeys = messageIds.map((id) => getMessageIndexKey(id));
+			const indexResults = await this.client.mGet(indexKeys);
+			const indexedIds = [];
+			const unindexedIds = [];
+			messageIds.forEach((id, i) => {
+				const threadId = indexResults[i];
+				if (threadId) {
+					indexedIds.push({
+						messageId: id,
+						threadId
+					});
+					return;
+				}
+				unindexedIds.push(id);
+			});
+			if (indexedIds.length > 0) {
+				const messageKeys = indexedIds.map(({ messageId, threadId }) => getMessageKey(threadId, messageId));
+				const messageResults = await this.client.mGet(messageKeys);
+				for (const data of messageResults) if (data) rawMessages.push(JSON.parse(data));
+			}
+			if (unindexedIds.length > 0) {
+				const threadKeys = await this.db.scanKeys("thread:*:messages");
+				const foundMessages = (await Promise.all(threadKeys.map(async (threadKey) => {
+					const threadId = threadKey.split(":")[1];
+					if (!threadId) throw new Error(`Failed to parse thread ID from thread key "${threadKey}"`);
+					const msgKeys = unindexedIds.map((id) => getMessageKey(threadId, id));
+					return this.client.mGet(msgKeys);
+				}))).flat(1).filter((data) => !!data).map((data) => JSON.parse(data));
+				rawMessages.push(...foundMessages);
+				if (foundMessages.length > 0) {
+					const multi = this.client.multi();
+					foundMessages.forEach((msg) => {
+						if (msg.threadId) multi.set(getMessageIndexKey(msg.id), msg.threadId);
+					});
+					await multi.exec();
+				}
+			}
+			return { messages: new MessageList().add(rawMessages.map(this.parseStoredMessage), "memory").get.all.db() };
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "LIST_MESSAGES_BY_ID", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { messageIds: JSON.stringify(messageIds) }
+			}, error);
+		}
+	}
+	async listMessages(args) {
+		const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+		const threadIds = Array.isArray(threadId) ? threadId : [threadId];
+		const threadIdsSet = new Set(threadIds);
+		if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) throw new MastraError({
+			id: createStorageErrorId("VALKEY", "LIST_MESSAGES", "INVALID_THREAD_ID"),
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { threadId: Array.isArray(threadId) ? threadId.join(",") : threadId }
+		}, /* @__PURE__ */ new Error("threadId must be a non-empty string or array of non-empty strings"));
+		const perPage = normalizePerPage(perPageInput, 40);
+		const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+		const metadataFilter = validateStorageMetadataFilter(filter?.metadata);
+		try {
+			if (page < 0) throw new MastraError({
+				id: createStorageErrorId("VALKEY", "LIST_MESSAGES", "INVALID_PAGE"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER,
+				details: { page }
+			}, /* @__PURE__ */ new Error("page must be >= 0"));
+			const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+			const getFieldValue = (msg) => {
+				if (field === "createdAt") return new Date(msg.createdAt).getTime();
+				const value = msg[field];
+				if (typeof value === "number") return value;
+				if (value instanceof Date) return value.getTime();
+				return 0;
+			};
+			if (perPage === 0 && (!include || include.length === 0)) return {
+				messages: [],
+				total: 0,
+				page,
+				perPage: perPageForResponse,
+				hasMore: false
+			};
+			let includedMessages = [];
+			if (include && include.length > 0) includedMessages = (await this.getIncludedMessages(include, resourceId)).map(this.parseStoredMessage);
+			if (perPage === 0 && include && include.length > 0) return {
+				messages: new MessageList().add(includedMessages, "memory").get.all.db().sort((a, b) => {
+					const aValue = getFieldValue(a);
+					const bValue = getFieldValue(b);
+					return direction === "ASC" ? aValue - bValue : bValue - aValue;
+				}),
+				total: 0,
+				page,
+				perPage: perPageForResponse,
+				hasMore: false
+			};
+			const allMessageIdsWithThreads = [];
+			for (const tid of threadIds) {
+				const threadMessagesKey = getThreadMessagesKey(tid);
+				const msgIds = await this.client.zRange(threadMessagesKey, 0, -1);
+				for (const mid of msgIds) allMessageIdsWithThreads.push({
+					threadId: tid,
+					messageId: mid
+				});
+			}
+			if (allMessageIdsWithThreads.length === 0) return {
+				messages: [],
+				total: 0,
+				page,
+				perPage: perPageForResponse,
+				hasMore: false
+			};
+			const messageKeys = allMessageIdsWithThreads.map(({ threadId: tid, messageId }) => getMessageKey(tid, messageId));
+			let messagesData = (await this.client.mGet(messageKeys)).filter((data) => data !== null).map((data) => JSON.parse(data)).map(this.parseStoredMessage);
+			if (resourceId) messagesData = messagesData.filter((msg) => msg.resourceId === resourceId);
+			messagesData = filterByDateRange(messagesData, (msg) => new Date(msg.createdAt), filter?.dateRange);
+			messagesData = messagesData.filter((message) => storageMessageMatchesMetadataFilter(message.content, metadataFilter));
+			messagesData.sort((a, b) => {
+				const aValue = getFieldValue(a);
+				const bValue = getFieldValue(b);
+				return direction === "ASC" ? aValue - bValue : bValue - aValue;
+			});
+			const total = messagesData.length;
+			const start = offset;
+			const end = perPageInput === false ? total : start + perPage;
+			const paginatedMessages = messagesData.slice(start, end);
+			const messageIdsSet = /* @__PURE__ */ new Set();
+			const allMessages = [];
+			for (const msg of paginatedMessages) {
+				if (messageIdsSet.has(msg.id)) continue;
+				allMessages.push(msg);
+				messageIdsSet.add(msg.id);
+			}
+			for (const msg of includedMessages) {
+				if (messageIdsSet.has(msg.id)) continue;
+				allMessages.push(msg);
+				messageIdsSet.add(msg.id);
+			}
+			let finalMessages = new MessageList().add(allMessages, "memory").get.all.db();
+			finalMessages = finalMessages.sort((a, b) => {
+				const aValue = getFieldValue(a);
+				const bValue = getFieldValue(b);
+				return direction === "ASC" ? aValue - bValue : bValue - aValue;
+			});
+			const returnedThreadMessageIds = new Set(finalMessages.filter((message) => message.threadId && threadIdsSet.has(message.threadId)).map((message) => message.id));
+			const hasMore = perPageInput !== false && (metadataFilter || returnedThreadMessageIds.size < total) && offset + paginatedMessages.length < total;
+			return {
+				messages: finalMessages,
+				total,
+				page,
+				perPage: perPageForResponse,
+				hasMore
+			};
+		} catch (error) {
+			if (error instanceof MastraError && error.category === ErrorCategory.USER) throw error;
+			const mastraError = new MastraError({
+				id: createStorageErrorId("VALKEY", "LIST_MESSAGES", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
+					resourceId: resourceId ?? ""
+				}
+			}, error);
+			this.logger.error(mastraError.toString());
+			this.logger.trackException(mastraError);
+			throw mastraError;
+		}
+	}
+	async getResourceById({ resourceId }) {
+		try {
+			const key = `${TABLE_RESOURCES}:${resourceId}`;
+			const data = await this.client.get(key);
+			if (!data) return null;
+			const resource = JSON.parse(data);
+			return {
+				...resource,
+				createdAt: new Date(resource.createdAt),
+				updatedAt: new Date(resource.updatedAt),
+				workingMemory: typeof resource.workingMemory === "object" ? JSON.stringify(resource.workingMemory) : resource.workingMemory,
+				metadata: typeof resource.metadata === "string" ? JSON.parse(resource.metadata) : resource.metadata
+			};
+		} catch (error) {
+			this.logger.error("Error getting resource by ID:", error);
+			throw error;
+		}
+	}
+	async saveResource({ resource }) {
+		try {
+			const key = `${TABLE_RESOURCES}:${resource.id}`;
+			const serializedResource = {
+				...resource,
+				metadata: JSON.stringify(resource.metadata),
+				createdAt: resource.createdAt.toISOString(),
+				updatedAt: resource.updatedAt.toISOString()
+			};
+			await this.client.set(key, JSON.stringify(serializedResource));
+			return resource;
+		} catch (error) {
+			this.logger.error("Error saving resource:", error);
+			throw error;
+		}
+	}
+	async updateResource({ resourceId, workingMemory, metadata }) {
+		try {
+			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 updatedResource = {
+				...existingResource,
+				workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+				metadata: {
+					...existingResource.metadata,
+					...metadata
+				},
+				updatedAt: /* @__PURE__ */ new Date()
+			};
+			await this.saveResource({ resource: updatedResource });
+			return updatedResource;
+		} catch (error) {
+			this.logger.error("Error updating resource:", error);
+			throw error;
+		}
+	}
+	async updateMessages(args) {
+		const { messages } = args;
+		if (messages.length === 0) return [];
+		try {
+			const messageIds = messages.map((m) => m.id);
+			const existingMessages = [];
+			const messageIdToKey = {};
+			for (const messageId of messageIds) {
+				const pattern = getMessageKey("*", messageId);
+				const keys = await this.db.scanKeys(pattern);
+				for (const key of keys) {
+					const data = await this.client.get(key);
+					if (!data) continue;
+					const message = JSON.parse(data);
+					if (message && message.id === messageId) {
+						existingMessages.push(message);
+						messageIdToKey[messageId] = key;
+						break;
+					}
+				}
+			}
+			if (existingMessages.length === 0) return [];
+			const threadIdsToUpdate = /* @__PURE__ */ new Set();
+			const multi = this.client.multi();
+			for (const existingMessage of existingMessages) {
+				const updatePayload = messages.find((m) => m.id === existingMessage.id);
+				if (!updatePayload) continue;
+				const { id, ...fieldsToUpdate } = updatePayload;
+				if (Object.keys(fieldsToUpdate).length === 0) continue;
+				threadIdsToUpdate.add(existingMessage.threadId);
+				if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) threadIdsToUpdate.add(updatePayload.threadId);
+				const updatedMessage = { ...existingMessage };
+				if (fieldsToUpdate.content) {
+					const existingContent = existingMessage.content;
+					updatedMessage.content = {
+						...existingContent,
+						...fieldsToUpdate.content,
+						...existingContent?.metadata && fieldsToUpdate.content.metadata ? { metadata: {
+							...existingContent.metadata,
+							...fieldsToUpdate.content.metadata
+						} } : {}
+					};
+				}
+				for (const key in fieldsToUpdate) if (Object.prototype.hasOwnProperty.call(fieldsToUpdate, key) && key !== "content") updatedMessage[key] = fieldsToUpdate[key];
+				const key = messageIdToKey[id];
+				if (!key) continue;
+				if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+					multi.zRem(getThreadMessagesKey(existingMessage.threadId), id);
+					multi.del(key);
+					const newKey = getMessageKey(updatePayload.threadId, id);
+					multi.set(newKey, JSON.stringify(updatedMessage));
+					multi.set(getMessageIndexKey(id), updatePayload.threadId);
+					const score = getMessageScore(updatedMessage);
+					multi.zAdd(getThreadMessagesKey(updatePayload.threadId), {
+						score,
+						value: id
+					});
+					messageIdToKey[id] = newKey;
+					continue;
+				}
+				multi.set(key, JSON.stringify(updatedMessage));
+			}
+			const now = /* @__PURE__ */ new Date();
+			for (const threadId of threadIdsToUpdate) if (threadId) {
+				const threadKey = getKey(TABLE_THREADS, { id: threadId });
+				const existingThreadData = await this.client.get(threadKey);
+				if (existingThreadData) {
+					const updatedThread = {
+						...JSON.parse(existingThreadData),
+						updatedAt: now
+					};
+					multi.set(threadKey, JSON.stringify(processRecord(TABLE_THREADS, updatedThread).processedRecord));
+				}
+			}
+			await multi.exec();
+			const updatedMessages = [];
+			for (const messageId of messageIds) {
+				const key = messageIdToKey[messageId];
+				if (key) {
+					const data = await this.client.get(key);
+					if (data) updatedMessages.push(JSON.parse(data));
+				}
+			}
+			return updatedMessages;
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "UPDATE_MESSAGES", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { messageIds: messages.map((m) => m.id).join(",") }
+			}, error);
+		}
+	}
+	async deleteMessages(messageIds) {
+		if (!messageIds || messageIds.length === 0) return;
+		try {
+			const threadIds = /* @__PURE__ */ new Set();
+			const messageKeys = [];
+			const foundMessageIds = [];
+			const messageIdToThreadId = /* @__PURE__ */ new Map();
+			const indexKeys = messageIds.map((id) => getMessageIndexKey(id));
+			const indexResults = await this.client.mGet(indexKeys);
+			const indexedMessages = [];
+			const unindexedMessageIds = [];
+			messageIds.forEach((id, i) => {
+				const threadId = indexResults[i];
+				if (threadId) {
+					indexedMessages.push({
+						messageId: id,
+						threadId
+					});
+					return;
+				}
+				unindexedMessageIds.push(id);
+			});
+			for (const { messageId, threadId } of indexedMessages) {
+				messageKeys.push(getMessageKey(threadId, messageId));
+				foundMessageIds.push(messageId);
+				messageIdToThreadId.set(messageId, threadId);
+				threadIds.add(threadId);
+			}
+			for (const messageId of unindexedMessageIds) {
+				const pattern = getMessageKey("*", messageId);
+				const keys = await this.db.scanKeys(pattern);
+				for (const key of keys) {
+					const data = await this.client.get(key);
+					if (!data) continue;
+					const message = JSON.parse(data);
+					if (message && message.id === messageId) {
+						messageKeys.push(key);
+						foundMessageIds.push(messageId);
+						if (message.threadId) {
+							messageIdToThreadId.set(messageId, message.threadId);
+							threadIds.add(message.threadId);
+						}
+						break;
+					}
+				}
+			}
+			if (messageKeys.length === 0) return;
+			const multi = this.client.multi();
+			for (const key of messageKeys) multi.del(key);
+			for (const messageId of foundMessageIds) multi.del(getMessageIndexKey(messageId));
+			if (threadIds.size > 0) for (const threadId of threadIds) {
+				for (const [msgId, msgThreadId] of messageIdToThreadId) if (msgThreadId === threadId) multi.zRem(getThreadMessagesKey(threadId), msgId);
+				const threadKey = getKey(TABLE_THREADS, { id: threadId });
+				const threadData = await this.client.get(threadKey);
+				if (!threadData) continue;
+				const updatedThread = {
+					...JSON.parse(threadData),
+					updatedAt: /* @__PURE__ */ new Date()
+				};
+				multi.set(threadKey, JSON.stringify(processRecord(TABLE_THREADS, updatedThread).processedRecord));
+			}
+			await multi.exec();
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "DELETE_MESSAGES", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { messageIds: messageIds.join(", ") }
+			}, error);
+		}
+	}
+	sortThreads(threads, field, direction) {
+		return threads.sort((a, b) => {
+			const aValue = new Date(a[field]).getTime();
+			const bValue = new Date(b[field]).getTime();
+			return direction === "ASC" ? aValue - bValue : bValue - aValue;
+		});
+	}
+	async cloneThread(args) {
+		const { sourceThreadId, newThreadId: providedThreadId, resourceId, title, metadata, options } = args;
+		const sourceThread = await this.getThreadById({ threadId: sourceThreadId });
+		if (!sourceThread) throw new MastraError({
+			id: createStorageErrorId("VALKEY", "CLONE_THREAD", "SOURCE_NOT_FOUND"),
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			text: `Source thread with id ${sourceThreadId} not found`,
+			details: { sourceThreadId }
+		});
+		const newThreadId = providedThreadId || crypto.randomUUID();
+		if (await this.getThreadById({ threadId: newThreadId })) throw new MastraError({
+			id: createStorageErrorId("VALKEY", "CLONE_THREAD", "THREAD_EXISTS"),
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			text: `Thread with id ${newThreadId} already exists`,
+			details: { newThreadId }
+		});
+		try {
+			const threadMessagesKey = getThreadMessagesKey(sourceThreadId);
+			const messageKeys = (await this.client.zRange(threadMessagesKey, 0, -1)).map((mid) => getMessageKey(sourceThreadId, mid));
+			let sourceMessages = [];
+			if (messageKeys.length > 0) sourceMessages = (await this.client.mGet(messageKeys)).filter((data) => data !== null).map((data) => {
+				const msg = JSON.parse(data);
+				return {
+					...msg,
+					createdAt: new Date(msg.createdAt)
+				};
+			});
+			if (options?.messageFilter?.startDate || options?.messageFilter?.endDate) sourceMessages = filterByDateRange(sourceMessages, (msg) => new Date(msg.createdAt), {
+				start: options.messageFilter?.startDate,
+				end: options.messageFilter?.endDate
+			});
+			if (options?.messageFilter?.messageIds && options.messageFilter.messageIds.length > 0) {
+				const messageIdSet = new Set(options.messageFilter.messageIds);
+				sourceMessages = sourceMessages.filter((msg) => messageIdSet.has(msg.id));
+			}
+			sourceMessages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+			if (options?.messageLimit && options.messageLimit > 0 && sourceMessages.length > options.messageLimit) sourceMessages = sourceMessages.slice(-options.messageLimit);
+			const now = /* @__PURE__ */ new Date();
+			const lastMessageId = sourceMessages.length > 0 ? sourceMessages[sourceMessages.length - 1].id : void 0;
+			const cloneMetadata = {
+				sourceThreadId,
+				clonedAt: now,
+				...lastMessageId && { lastMessageId }
+			};
+			const newThread = {
+				id: newThreadId,
+				resourceId: resourceId || sourceThread.resourceId,
+				title: title || (sourceThread.title ? `Clone of ${sourceThread.title}` : void 0),
+				metadata: {
+					...metadata,
+					clone: cloneMetadata
+				},
+				createdAt: now,
+				updatedAt: now
+			};
+			const multi = this.client.multi();
+			const threadKey = getKey(TABLE_THREADS, { id: newThreadId });
+			multi.set(threadKey, JSON.stringify(processRecord(TABLE_THREADS, newThread).processedRecord));
+			const clonedMessages = [];
+			const targetResourceId = resourceId || sourceThread.resourceId;
+			const newThreadMessagesKey = getThreadMessagesKey(newThreadId);
+			for (let i = 0; i < sourceMessages.length; i++) {
+				const sourceMsg = sourceMessages[i];
+				const newMessageId = crypto.randomUUID();
+				const { _index, ...restMsg } = sourceMsg;
+				const newMessage = {
+					...restMsg,
+					id: newMessageId,
+					threadId: newThreadId,
+					resourceId: targetResourceId
+				};
+				const messageKey = getMessageKey(newThreadId, newMessageId);
+				multi.set(messageKey, JSON.stringify(newMessage));
+				multi.set(getMessageIndexKey(newMessageId), newThreadId);
+				const score = getMessageScore({
+					createdAt: newMessage.createdAt,
+					_index: i
+				});
+				multi.zAdd(newThreadMessagesKey, {
+					score,
+					value: newMessageId
+				});
+				clonedMessages.push(newMessage);
+			}
+			await multi.exec();
+			return {
+				thread: newThread,
+				clonedMessages
+			};
+		} catch (error) {
+			if (error instanceof MastraError) throw error;
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "CLONE_THREAD", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					sourceThreadId,
+					newThreadId
+				}
+			}, error);
+		}
+	}
+};
+function getThreadMessagesKey(threadId) {
+	return `thread:${threadId}:messages`;
+}
+function getMessageKey(threadId, messageId) {
+	return getKey(TABLE_MESSAGES, {
+		threadId,
+		id: messageId
+	});
+}
+function getMessageIndexKey(messageId) {
+	return `msg-idx:${messageId}`;
+}
+function getMessageScore(message) {
+	const createdAtScore = new Date(message.createdAt).getTime();
+	const index = typeof message._index === "number" ? message._index : 0;
+	return createdAtScore * 1e3 + index;
+}
+//#endregion
+//#region src/storage/domains/scores/index.ts
+/** Returns true when a row matches the multi-tenant scope filters (or none provided). */
+function matchesTenancy(row, filters) {
+	if (filters?.organizationId !== void 0 && row.organizationId !== filters.organizationId) return false;
+	if (filters?.projectId !== void 0 && row.projectId !== filters.projectId) return false;
+	return true;
+}
+var ScoresValkey = class extends ScoresStorage {
+	client;
+	db;
+	constructor(config) {
+		super();
+		this.client = config.client;
+		this.db = new ValkeyDB({ client: config.client });
+	}
+	async dangerouslyClearAll() {
+		await this.db.deleteData({ tableName: TABLE_SCORERS });
+	}
+	async getScoreById({ id }) {
+		try {
+			const data = await this.db.get({
+				tableName: TABLE_SCORERS,
+				keys: { id }
+			});
+			if (!data) return null;
+			return transformScoreRow(data);
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "GET_SCORE_BY_ID", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { ...id && { id } }
+			}, error);
+		}
+	}
+	async listScoresByScorerId({ scorerId, entityId, entityType, source, pagination = {
+		page: 0,
+		perPage: 20
+	}, filters }) {
+		return this.fetchAndFilterScores(pagination, (row) => {
+			if (row.scorerId !== scorerId) return false;
+			if (entityId && row.entityId !== entityId) return false;
+			if (entityType && row.entityType !== entityType) return false;
+			if (source && row.source !== source) return false;
+			if (!matchesTenancy(row, filters)) return false;
+			return true;
+		});
+	}
+	async saveScore(score) {
+		let validatedScore;
+		try {
+			validatedScore = saveScorePayloadSchema.parse(score);
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "SAVE_SCORE", "VALIDATION_FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: 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 now = /* @__PURE__ */ new Date();
+		const id = crypto$1.randomUUID();
+		const { key, processedRecord } = processRecord(TABLE_SCORERS, {
+			...validatedScore,
+			id,
+			createdAt: now,
+			updatedAt: now
+		});
+		try {
+			await this.client.set(key, JSON.stringify(processedRecord));
+			return { score: {
+				...validatedScore,
+				id,
+				createdAt: now,
+				updatedAt: now
+			} };
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "SAVE_SCORE", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { id }
+			}, error);
+		}
+	}
+	async listScoresByRunId({ runId, pagination = {
+		page: 0,
+		perPage: 20
+	}, filters }) {
+		return this.fetchAndFilterScores(pagination, (row) => row.runId === runId && matchesTenancy(row, filters));
+	}
+	async listScoresByEntityId({ entityId, entityType, pagination = {
+		page: 0,
+		perPage: 20
+	}, filters }) {
+		return this.fetchAndFilterScores(pagination, (row) => {
+			if (row.entityId !== entityId) return false;
+			if (entityType && row.entityType !== entityType) return false;
+			if (!matchesTenancy(row, filters)) return false;
+			return true;
+		});
+	}
+	async listScoresBySpan({ traceId, spanId, pagination = {
+		page: 0,
+		perPage: 20
+	}, filters }) {
+		return this.fetchAndFilterScores(pagination, (row) => row.traceId === traceId && row.spanId === spanId && matchesTenancy(row, filters));
+	}
+	async fetchAndFilterScores(pagination, filterFn) {
+		const { page, perPage: perPageInput } = pagination;
+		const keys = await this.db.scanKeys(`${TABLE_SCORERS}:*`);
+		if (keys.length === 0) return {
+			scores: [],
+			pagination: {
+				total: 0,
+				page,
+				perPage: perPageInput,
+				hasMore: false
+			}
+		};
+		const filtered = (await this.client.mGet(keys)).map((data) => {
+			if (!data) return null;
+			try {
+				return JSON.parse(data);
+			} catch {
+				return null;
+			}
+		}).filter((row) => !!row && typeof row === "object" && filterFn(row));
+		const total = filtered.length;
+		const perPage = normalizePerPage(perPageInput, 100);
+		const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+		const end = perPageInput === false ? total : start + perPage;
+		return {
+			scores: filtered.slice(start, end).map((row) => transformScoreRow(row)),
+			pagination: {
+				total,
+				page,
+				perPage: perPageForResponse,
+				hasMore: end < total
+			}
+		};
+	}
+};
+//#endregion
+//#region src/storage/domains/workflows/index.ts
+function parseWorkflowRun(row) {
+	let parsedSnapshot = row.snapshot;
+	if (typeof parsedSnapshot === "string") try {
+		parsedSnapshot = JSON.parse(row.snapshot);
+	} catch (e) {
+		console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+	}
+	return {
+		workflowName: row.workflow_name,
+		runId: row.run_id,
+		snapshot: parsedSnapshot,
+		createdAt: ensureDate(row.createdAt),
+		updatedAt: ensureDate(row.updatedAt),
+		resourceId: row.resourceId
+	};
+}
+var WorkflowsValkey = class extends WorkflowsStorage {
+	client;
+	db;
+	constructor(config) {
+		super();
+		this.client = config.client;
+		this.db = new ValkeyDB({ client: config.client });
+	}
+	supportsConcurrentUpdates() {
+		return false;
+	}
+	async dangerouslyClearAll() {
+		await this.db.deleteData({ tableName: TABLE_WORKFLOW_SNAPSHOT });
+	}
+	async updateWorkflowResults({ workflowName, runId, stepId, result, requestContext }) {
+		try {
+			const existingRecord = await this.db.get({
+				tableName: TABLE_WORKFLOW_SNAPSHOT,
+				keys: {
+					namespace: "workflows",
+					workflow_name: workflowName,
+					run_id: runId
+				}
+			});
+			let snapshot = existingRecord?.snapshot;
+			if (!snapshot) snapshot = {
+				context: {},
+				activePaths: [],
+				timestamp: Date.now(),
+				suspendedPaths: {},
+				activeStepsPath: {},
+				resumeLabels: {},
+				serializedStepGraph: [],
+				status: "pending",
+				value: {},
+				waitingPaths: {},
+				runId,
+				requestContext: {}
+			};
+			snapshot.context[stepId] = result;
+			snapshot.requestContext = {
+				...snapshot.requestContext,
+				...requestContext
+			};
+			await this.persistWorkflowSnapshot({
+				namespace: "workflows",
+				workflowName,
+				runId,
+				snapshot,
+				createdAt: existingRecord?.createdAt ? ensureDate(existingRecord.createdAt) : void 0
+			});
+			return snapshot.context;
+		} catch (error) {
+			if (error instanceof MastraError) throw error;
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "UPDATE_WORKFLOW_RESULTS", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					workflowName,
+					runId,
+					stepId
+				}
+			}, error);
+		}
+	}
+	async updateWorkflowState({ workflowName, runId, opts }) {
+		try {
+			const existingRecord = await this.db.get({
+				tableName: TABLE_WORKFLOW_SNAPSHOT,
+				keys: {
+					namespace: "workflows",
+					workflow_name: workflowName,
+					run_id: runId
+				}
+			});
+			const existingSnapshot = existingRecord?.snapshot;
+			if (!existingSnapshot || !existingSnapshot.context) return;
+			const { expectedStatus, ...state } = opts;
+			if (!matchesExpectedWorkflowStatus(existingSnapshot.status, expectedStatus)) return;
+			const updatedSnapshot = {
+				...existingSnapshot,
+				...state
+			};
+			await this.persistWorkflowSnapshot({
+				namespace: "workflows",
+				workflowName,
+				runId,
+				snapshot: updatedSnapshot,
+				createdAt: existingRecord?.createdAt ? ensureDate(existingRecord.createdAt) : void 0
+			});
+			return updatedSnapshot;
+		} catch (error) {
+			if (error instanceof MastraError) throw error;
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "UPDATE_WORKFLOW_STATE", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					workflowName,
+					runId
+				}
+			}, error);
+		}
+	}
+	async persistWorkflowSnapshot(params) {
+		const { namespace = "workflows", workflowName, runId, resourceId, snapshot, createdAt, updatedAt } = params;
+		try {
+			let finalCreatedAt = createdAt;
+			if (!finalCreatedAt) {
+				const existing = await this.db.get({
+					tableName: TABLE_WORKFLOW_SNAPSHOT,
+					keys: {
+						namespace,
+						workflow_name: workflowName,
+						run_id: runId
+					}
+				});
+				finalCreatedAt = existing?.createdAt ? ensureDate(existing.createdAt) : /* @__PURE__ */ new Date();
+			}
+			await this.db.insert({
+				tableName: TABLE_WORKFLOW_SNAPSHOT,
+				record: {
+					namespace,
+					workflow_name: workflowName,
+					run_id: runId,
+					resourceId,
+					snapshot,
+					createdAt: finalCreatedAt,
+					updatedAt: updatedAt ?? /* @__PURE__ */ new Date()
+				}
+			});
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					namespace,
+					workflowName,
+					runId
+				}
+			}, error);
+		}
+	}
+	async loadWorkflowSnapshot(params) {
+		const { namespace = "workflows", workflowName, runId } = params;
+		const key = getKey(TABLE_WORKFLOW_SNAPSHOT, {
+			namespace,
+			workflow_name: workflowName,
+			run_id: runId
+		});
+		try {
+			const data = await this.client.get(key);
+			if (!data) return null;
+			return JSON.parse(data).snapshot;
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "LOAD_WORKFLOW_SNAPSHOT", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					namespace,
+					workflowName,
+					runId
+				}
+			}, error);
+		}
+	}
+	async getWorkflowRunById({ runId, workflowName }) {
+		try {
+			const key = getKey(TABLE_WORKFLOW_SNAPSHOT, {
+				namespace: "workflows",
+				workflow_name: workflowName,
+				run_id: runId
+			}) + "*";
+			const keys = await this.db.scanKeys(key);
+			if (keys.length === 0) return null;
+			const data = (await this.client.mGet(keys)).filter((data) => data !== null).map((data) => JSON.parse(data)).find((workflow) => {
+				if (!workflow) return false;
+				const runIdMatch = workflow.run_id === runId;
+				if (workflowName) return runIdMatch && workflow.workflow_name === workflowName;
+				return runIdMatch;
+			});
+			if (!data) return null;
+			return parseWorkflowRun(data);
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					namespace: "workflows",
+					runId,
+					workflowName: workflowName || ""
+				}
+			}, error);
+		}
+	}
+	async deleteWorkflowRunById({ runId, workflowName }) {
+		const key = getKey(TABLE_WORKFLOW_SNAPSHOT, {
+			namespace: "workflows",
+			workflow_name: workflowName,
+			run_id: runId
+		});
+		try {
+			await this.client.del(key);
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					namespace: "workflows",
+					runId,
+					workflowName
+				}
+			}, error);
+		}
+	}
+	async listWorkflowRuns({ workflowName, fromDate, toDate, perPage, page, resourceId, status } = {}) {
+		try {
+			if (page !== void 0 && page < 0) throw new MastraError({
+				id: createStorageErrorId("VALKEY", "LIST_WORKFLOW_RUNS", "INVALID_PAGE"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER,
+				details: { page }
+			}, /* @__PURE__ */ new Error("page must be >= 0"));
+			const normalizedFrom = fromDate ? ensureDate(fromDate) : void 0;
+			const normalizedTo = toDate ? ensureDate(toDate) : void 0;
+			let pattern = getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows" }) + ":*";
+			if (workflowName && resourceId) pattern = getKey(TABLE_WORKFLOW_SNAPSHOT, {
+				namespace: "workflows",
+				workflow_name: workflowName,
+				run_id: "*",
+				resourceId
+			});
+			else if (workflowName) pattern = getKey(TABLE_WORKFLOW_SNAPSHOT, {
+				namespace: "workflows",
+				workflow_name: workflowName
+			}) + ":*";
+			else if (resourceId) pattern = getKey(TABLE_WORKFLOW_SNAPSHOT, {
+				namespace: "workflows",
+				workflow_name: "*",
+				run_id: "*",
+				resourceId
+			});
+			const keys = await this.db.scanKeys(pattern);
+			if (keys.length === 0) return {
+				runs: [],
+				total: 0
+			};
+			let runs = (await this.client.mGet(keys)).filter((data) => data !== null).map((data) => JSON.parse(data)).filter((record) => record !== null && record !== void 0 && typeof record === "object" && "workflow_name" in record).filter((record) => !workflowName || record.workflow_name === workflowName).map((w) => parseWorkflowRun(w)).filter((w) => {
+				if (normalizedFrom && w.createdAt < normalizedFrom) return false;
+				if (normalizedTo && w.createdAt > normalizedTo) return false;
+				if (status) {
+					let snapshot = w.snapshot;
+					if (typeof snapshot === "string") try {
+						snapshot = JSON.parse(snapshot);
+					} catch (e) {
+						console.warn(`Failed to parse snapshot for workflow ${w.workflowName}: ${e}`);
+						return false;
+					}
+					return snapshot.status === status;
+				}
+				return true;
+			}).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+			const total = runs.length;
+			if (typeof perPage === "number" && typeof page === "number") {
+				const normalizedPerPage = normalizePerPage(perPage, Number.MAX_SAFE_INTEGER);
+				const offset = page * normalizedPerPage;
+				runs = runs.slice(offset, offset + normalizedPerPage);
+			}
+			return {
+				runs,
+				total
+			};
+		} catch (error) {
+			if (error instanceof MastraError) throw error;
+			throw new MastraError({
+				id: createStorageErrorId("VALKEY", "LIST_WORKFLOW_RUNS", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					namespace: "workflows",
+					workflowName: workflowName || "",
+					resourceId: resourceId || ""
+				}
+			}, error);
+		}
+	}
+};
+//#endregion
+//#region src/client.ts
+const asString = (value) => {
+	if (typeof value === "string") return value;
+	if (Buffer.isBuffer(value)) return value.toString();
+	return String(value);
+};
+const asNullableString = (value) => value === null ? null : asString(value);
+const asNumber = (value) => Number(value);
+var GlideMultiAdapter = class {
+	getClient;
+	batch = new Batch(true);
+	constructor(getClient) {
+		this.getClient = getClient;
+	}
+	del(key) {
+		this.batch.customCommand(["DEL", key]);
+		return this;
+	}
+	set(key, value) {
+		this.batch.customCommand([
+			"SET",
+			key,
+			value
+		]);
+		return this;
+	}
+	zAdd(key, value) {
+		this.batch.customCommand([
+			"ZADD",
+			key,
+			String(value.score),
+			value.value
+		]);
+		return this;
+	}
+	zRem(key, value) {
+		this.batch.customCommand([
+			"ZREM",
+			key,
+			value
+		]);
+		return this;
+	}
+	async exec() {
+		return (await this.getClient()).exec(this.batch, true, { decoder: Decoder.String });
+	}
+};
+var GlideValkeyClient = class {
+	config;
+	suppliedClient;
+	clientPromise;
+	constructor(config, suppliedClient) {
+		this.config = config;
+		this.suppliedClient = suppliedClient;
+	}
+	get isOpen() {
+		return this.clientPromise !== void 0 || this.suppliedClient !== void 0;
+	}
+	connect() {
+		return this.getClient().then(() => void 0);
+	}
+	async quit() {
+		(await this.getClient()).close();
+	}
+	async get(key) {
+		return asNullableString(await this.command(["GET", key]));
+	}
+	async set(key, value) {
+		return this.command([
+			"SET",
+			key,
+			value
+		]);
+	}
+	async mGet(keys) {
+		if (keys.length === 0) return [];
+		return (await this.command(["MGET", ...keys])).map(asNullableString);
+	}
+	async del(keys) {
+		const values = Array.isArray(keys) ? keys : [keys];
+		if (values.length === 0) return 0;
+		return asNumber(await this.command(["DEL", ...values]));
+	}
+	async scan(cursor, options) {
+		const result = await this.command([
+			"SCAN",
+			cursor,
+			"MATCH",
+			options.MATCH,
+			"COUNT",
+			String(options.COUNT)
+		]);
+		return {
+			cursor: asString(result[0]),
+			keys: result[1].map(asString)
+		};
+	}
+	async zRange(key, start, stop) {
+		return (await this.command([
+			"ZRANGE",
+			key,
+			String(start),
+			String(stop)
+		])).map(asString);
+	}
+	async zRank(key, value) {
+		const result = await this.command([
+			"ZRANK",
+			key,
+			value
+		]);
+		return result === null ? null : asNumber(result);
+	}
+	async zAdd(key, value) {
+		return asNumber(await this.command([
+			"ZADD",
+			key,
+			String(value.score),
+			value.value
+		]));
+	}
+	async zRem(key, value) {
+		return asNumber(await this.command([
+			"ZREM",
+			key,
+			value
+		]));
+	}
+	multi() {
+		return new GlideMultiAdapter(() => this.getClient());
+	}
+	getClient() {
+		if (this.suppliedClient) return Promise.resolve(this.suppliedClient);
+		this.clientPromise ??= GlideClient.createClient(this.config);
+		return this.clientPromise;
+	}
+	async command(args) {
+		return (await this.getClient()).customCommand(args, { decoder: Decoder.String });
+	}
+};
+//#endregion
+//#region src/storage/store.ts
+/** GLIDE-backed Valkey storage adapter for Mastra. */
+var ValkeyStore = class extends MastraStorage {
+	client;
+	shouldManageConnection;
+	stores;
+	constructor(config) {
+		super({
+			id: config.id,
+			name: "Valkey",
+			disableInit: config.disableInit
+		});
+		if ("client" in config) {
+			this.client = new GlideValkeyClient(void 0, config.client);
+			this.shouldManageConnection = false;
+		} else {
+			const glideConfig = "config" in config ? config.config : {
+				addresses: [{
+					host: config.host,
+					port: config.port ?? 6379
+				}],
+				databaseId: config.db ?? 0,
+				credentials: config.password ? {
+					username: config.username ?? "default",
+					password: config.password
+				} : void 0,
+				useTLS: config.useTLS
+			};
+			this.client = new GlideValkeyClient(glideConfig);
+			this.shouldManageConnection = true;
+		}
+		this.stores = {
+			scores: new ScoresValkey({ client: this.client }),
+			workflows: new WorkflowsValkey({ client: this.client }),
+			memory: new StoreMemoryValkey({ client: this.client })
+		};
+	}
+	async init() {
+		if (this.shouldManageConnection) await this.client.connect();
+		await super.init();
+	}
+	getClient() {
+		return this.client;
+	}
+	async close() {
+		if (this.shouldManageConnection) await this.client.quit();
+	}
+};
+//#endregion
+//#region src/cache.ts
+const stringValue = (value) => Buffer.isBuffer(value) ? value.toString() : String(value);
+/** GLIDE-backed Valkey cache for Mastra server state. */
+var ValkeyServerCache = class extends MastraServerCache {
+	client;
+	keyPrefix;
+	ttlSeconds;
+	constructor(config, options = {}) {
+		super({ name: "ValkeyServerCache" });
+		this.client = config.client;
+		this.keyPrefix = options.keyPrefix ?? "mastra:cache:";
+		this.ttlSeconds = options.ttlSeconds ?? 300;
+	}
+	getKey(key) {
+		return `${this.keyPrefix}${key}`;
+	}
+	async command(args) {
+		return this.client.customCommand(args, { decoder: Decoder.String });
+	}
+	async get(key) {
+		const value = await this.command(["GET", this.getKey(key)]);
+		if (value === null) return null;
+		const serialized = stringValue(value);
+		try {
+			return JSON.parse(serialized);
+		} catch {
+			return serialized;
+		}
+	}
+	async set(key, value, ttlMs) {
+		const args = [
+			"SET",
+			this.getKey(key),
+			JSON.stringify(value)
+		];
+		const seconds = ttlMs === void 0 ? this.ttlSeconds : Math.max(1, Math.ceil(ttlMs / 1e3));
+		if (seconds > 0) args.push("EX", String(seconds));
+		await this.command(args);
+	}
+	async listLength(key) {
+		return Number(await this.command(["LLEN", this.getKey(key)]));
+	}
+	async listPush(key, value) {
+		const fullKey = this.getKey(key);
+		await this.command([
+			"RPUSH",
+			fullKey,
+			JSON.stringify(value)
+		]);
+		if (this.ttlSeconds > 0) await this.command([
+			"EXPIRE",
+			fullKey,
+			String(this.ttlSeconds)
+		]);
+	}
+	async listFromTo(key, from, to = -1) {
+		return (await this.command([
+			"LRANGE",
+			this.getKey(key),
+			String(from),
+			String(to)
+		])).map((value) => {
+			const serialized = stringValue(value);
+			try {
+				return JSON.parse(serialized);
+			} catch {
+				return serialized;
+			}
+		});
+	}
+	async delete(key) {
+		await this.command(["DEL", this.getKey(key)]);
+	}
+	async clear() {
+		let cursor = "0";
+		do {
+			const result = await this.command([
+				"SCAN",
+				cursor,
+				"MATCH",
+				`${this.keyPrefix}*`,
+				"COUNT",
+				"100"
+			]);
+			cursor = stringValue(result[0]);
+			const keys = result[1].map(stringValue);
+			if (keys.length > 0) await this.command(["DEL", ...keys]);
+		} while (cursor !== "0");
+	}
+	async increment(key) {
+		const fullKey = this.getKey(key);
+		const value = Number(await this.command(["INCR", fullKey]));
+		if (this.ttlSeconds > 0) await this.command([
+			"EXPIRE",
+			fullKey,
+			String(this.ttlSeconds)
+		]);
+		return value;
+	}
+};
+//#endregion
+export { ScoresValkey, StoreMemoryValkey, ValkeyServerCache, ValkeyStore, WorkflowsValkey };
+
+//# sourceMappingURL=index.js.map