@mastra/elasticsearch 1.3.1 → 1.4.0

package/dist/index.js

@@ -1,10 +1,13 @@
 import { Client } from "@elastic/elasticsearch";
 import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
-import { createVectorErrorId } from "@mastra/core/storage";
+import { MastraStorage, MemoryStorage, ScoresStorage, TABLE_MESSAGES, TABLE_RESOURCES, TABLE_SCORERS, TABLE_THREADS, TABLE_WORKFLOW_SNAPSHOT, WorkflowsStorage, calculatePagination, createStorageErrorId, createVectorErrorId, ensureDate, filterByDateRange, jsonValueEquals, matchesExpectedWorkflowStatus, normalizePerPage, serializeDate, storageMessageMatchesMetadataFilter, transformScoreRow, validateStorageMetadataFilter } from "@mastra/core/storage";
 import { MastraVector, validateTopK, validateUpsert } from "@mastra/core/vector";
 import { BaseFilterTranslator } from "@mastra/core/vector/filter";
+import { MessageList } from "@mastra/core/agent";
+import crypto$1 from "crypto";
+import { saveScorePayloadSchema } from "@mastra/core/evals";
 //#region package.json
-var version = "1.3.1";
+var version = "1.4.0";
 //#endregion
 //#region src/vector/filter.ts
 /**
@@ -840,6 +843,1618 @@ var ElasticSearchVector = class extends MastraVector {
 	}
 };
 //#endregion
-export { ElasticSearchVector };
+//#region src/storage/domains/utils.ts
+/**
+* Generate a document key from table name and key parts.
+*
+* @example
+* ```typescript
+* getKey('mastra_threads', { id: 'thread-123' });
+* // Returns: 'mastra_threads:id:thread-123'
+* ```
+*/
+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 document id 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.ts
+const SEARCH_PAGE_SIZE = 1e3;
+/**
+* Thin document-store layer over ElasticSearch.
+*
+* Each Mastra table maps to one ElasticSearch index (same name, already lowercase).
+* Records are stored as opaque JSON strings in a non-indexed `doc` field, with a
+* `key` keyword field (copy of `_id`) used for stable `search_after` pagination.
+*
+* ElasticSearch is near-real-time: all writes use `refresh: true` so
+* subsequent searches observe them, and point reads use `_get` by id (which is
+* real-time regardless of refresh).
+*/
+var ElasticSearchDB = class {
+	client;
+	ensuredIndexes = /* @__PURE__ */ new Set();
+	constructor({ client }) {
+		this.client = client;
+	}
+	getClient() {
+		return this.client;
+	}
+	async ensureIndex(tableName) {
+		if (this.ensuredIndexes.has(tableName)) return;
+		try {
+			if (!await this.client.indices.exists({ index: tableName })) await this.client.indices.create({
+				index: tableName,
+				mappings: {
+					dynamic: false,
+					properties: {
+						key: { type: "keyword" },
+						doc: {
+							type: "text",
+							index: false
+						}
+					}
+				}
+			});
+			this.ensuredIndexes.add(tableName);
+		} catch (error) {
+			const message = error?.message || error?.toString();
+			if (message && message.toLowerCase().includes("already exists")) {
+				this.ensuredIndexes.add(tableName);
+				return;
+			}
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "ENSURE_INDEX", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async insert({ tableName, record }) {
+		const { key, processedRecord } = processRecord(tableName, record);
+		await this.set({
+			tableName,
+			key,
+			value: processedRecord
+		});
+	}
+	async set({ tableName, key, value }) {
+		await this.ensureIndex(tableName);
+		try {
+			await this.client.index({
+				index: tableName,
+				id: key,
+				document: {
+					key,
+					doc: JSON.stringify(value)
+				},
+				refresh: true
+			});
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "INSERT", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async bulkSet({ tableName, entries }) {
+		if (entries.length === 0) return;
+		await this.ensureIndex(tableName);
+		try {
+			const operations = entries.flatMap(({ key, value }) => [{ index: {
+				_index: tableName,
+				_id: key
+			} }, {
+				key,
+				doc: JSON.stringify(value)
+			}]);
+			const response = await this.client.bulk({
+				operations,
+				refresh: true
+			});
+			if (response.errors) {
+				const firstError = response.items.find((item) => item.index?.error)?.index?.error;
+				throw new Error(`Bulk write failed: ${firstError?.reason ?? "unknown error"}`);
+			}
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "BATCH_INSERT", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async get({ tableName, keys }) {
+		const key = getKey(tableName, keys);
+		return this.getByKey({
+			tableName,
+			key
+		});
+	}
+	async getByKey({ tableName, key }) {
+		await this.ensureIndex(tableName);
+		try {
+			const response = await this.client.get({
+				index: tableName,
+				id: key
+			}, { ignore: [404] });
+			if (!response.found || !response._source?.doc) return null;
+			return JSON.parse(response._source.doc);
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "LOAD", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	/**
+	* Returns all documents in a table, parsed. Uses `search_after` on the `key`
+	* field for stable deep pagination.
+	*/
+	async listAll({ tableName, keyPrefix }) {
+		return (await this.listAllEntries({
+			tableName,
+			keyPrefix
+		})).map((entry) => entry.value);
+	}
+	/**
+	* Returns all `{ key, value }` entries in a table (optionally filtered by key
+	* prefix), using `search_after` pagination.
+	*/
+	async listAllEntries({ tableName, keyPrefix }) {
+		await this.ensureIndex(tableName);
+		try {
+			const results = [];
+			let searchAfter;
+			while (true) {
+				const hits = (await this.client.search({
+					index: tableName,
+					size: SEARCH_PAGE_SIZE,
+					query: keyPrefix ? { prefix: { key: keyPrefix } } : { match_all: {} },
+					sort: [{ key: "asc" }],
+					...searchAfter ? { search_after: searchAfter } : {}
+				})).hits.hits;
+				for (const hit of hits) if (hit._source?.doc) results.push({
+					key: hit._source.key,
+					value: JSON.parse(hit._source.doc)
+				});
+				if (hits.length < SEARCH_PAGE_SIZE) break;
+				searchAfter = hits[hits.length - 1].sort;
+			}
+			return results;
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "SCAN", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async delete({ tableName, key }) {
+		await this.ensureIndex(tableName);
+		try {
+			await this.client.delete({
+				index: tableName,
+				id: key,
+				refresh: true
+			}, { ignore: [404] });
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "DELETE", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async deleteMany({ tableName, keys }) {
+		if (keys.length === 0) return;
+		await this.ensureIndex(tableName);
+		try {
+			await this.client.deleteByQuery({
+				index: tableName,
+				query: { terms: { key: keys } },
+				refresh: true,
+				conflicts: "proceed"
+			});
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "DELETE_MANY", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+	async deleteData({ tableName, keyPrefix }) {
+		await this.ensureIndex(tableName);
+		try {
+			await this.client.deleteByQuery({
+				index: tableName,
+				query: keyPrefix ? { prefix: { key: keyPrefix } } : { match_all: {} },
+				refresh: true,
+				conflicts: "proceed"
+			});
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "CLEAR_TABLE", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
+};
+//#endregion
+//#region src/storage/domains/memory/index.ts
+var MemoryElasticSearch = class extends MemoryStorage {
+	supportsPartialThreadUpdate = true;
+	db;
+	constructor(config) {
+		super();
+		this.db = new ElasticSearchDB({ 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 });
+	}
+	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("ELASTICSEARCH", "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("ELASTICSEARCH", "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("ELASTICSEARCH", "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 {
+			const allThreads = [];
+			const results = await this.db.listAll({ tableName: TABLE_THREADS });
+			for (const thread of results) {
+				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("ELASTICSEARCH", "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("ELASTICSEARCH", "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("ELASTICSEARCH", "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("ELASTICSEARCH", "UPDATE_THREAD", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { threadId: id }
+			}, error);
+		}
+	}
+	async deleteThread({ threadId }) {
+		try {
+			const entries = await this.db.listAllEntries({
+				tableName: TABLE_MESSAGES,
+				keyPrefix: threadMessagesPrefix(threadId)
+			});
+			const keysToDelete = [...entries.map((entry) => entry.key), ...entries.map((entry) => getMessageIndexKey(entry.value.id))];
+			await this.db.deleteMany({
+				tableName: TABLE_MESSAGES,
+				keys: keysToDelete
+			});
+			await this.db.delete({
+				tableName: TABLE_THREADS,
+				key: getKey(TABLE_THREADS, { id: threadId })
+			});
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "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;
+		let existingThread = null;
+		try {
+			if (!threadId) throw new Error("Thread ID is required");
+			existingThread = await this.getThreadById({ threadId });
+			if (!existingThread) throw new Error(`Thread ${threadId} not found`);
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "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
+			};
+		});
+		try {
+			const keysToDelete = [];
+			const entries = [];
+			for (const message of messagesWithIndex) {
+				const existingIndex = await this.db.getByKey({
+					tableName: TABLE_MESSAGES,
+					key: getMessageIndexKey(message.id)
+				});
+				if (existingIndex?.threadId && existingIndex.threadId !== message.threadId) keysToDelete.push(getMessageKey(existingIndex.threadId, message.id));
+				entries.push({
+					key: getMessageKey(message.threadId, message.id),
+					value: message
+				});
+				entries.push({
+					key: getMessageIndexKey(message.id),
+					value: { threadId: message.threadId }
+				});
+			}
+			await this.db.deleteMany({
+				tableName: TABLE_MESSAGES,
+				keys: keysToDelete
+			});
+			await this.db.bulkSet({
+				tableName: TABLE_MESSAGES,
+				entries
+			});
+			const updatedThread = {
+				...existingThread,
+				updatedAt: /* @__PURE__ */ new Date()
+			};
+			await this.db.insert({
+				tableName: TABLE_THREADS,
+				record: updatedThread
+			});
+			return { messages: new MessageList().add(messages, "memory").get.all.db() };
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "SAVE_MESSAGES", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { threadId }
+			}, error);
+		}
+	}
+	/**
+	* Returns all messages that belong to a thread, sorted in insertion order
+	* (createdAt with `_index` tiebreaker).
+	*/
+	async listThreadMessages(threadId) {
+		return (await this.db.listAll({
+			tableName: TABLE_MESSAGES,
+			keyPrefix: threadMessagesPrefix(threadId)
+		})).sort((a, b) => getMessageScore(a) - getMessageScore(b));
+	}
+	/** Returns all message documents across all threads (excludes index docs). */
+	async listAllMessages() {
+		return this.db.listAll({
+			tableName: TABLE_MESSAGES,
+			keyPrefix: `${TABLE_MESSAGES}:threadId:`
+		});
+	}
+	async getThreadIdForMessage(messageId) {
+		const indexed = await this.db.getByKey({
+			tableName: TABLE_MESSAGES,
+			key: getMessageIndexKey(messageId)
+		});
+		if (indexed?.threadId) return indexed.threadId;
+		const message = (await this.listAllMessages()).find((msg) => msg.id === messageId);
+		if (!message) return null;
+		if (message.threadId) await this.db.set({
+			tableName: TABLE_MESSAGES,
+			key: getMessageIndexKey(messageId),
+			value: { threadId: 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 messagesById = /* @__PURE__ */ new Map();
+		for (const item of include) {
+			const itemThreadId = await this.getThreadIdForMessage(item.id);
+			if (!itemThreadId) continue;
+			let threadMessages = await this.listThreadMessages(itemThreadId);
+			if (resourceId !== void 0) threadMessages = threadMessages.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)) messagesById.set(message.id, message);
+		}
+		return Array.from(messagesById.values());
+	}
+	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 unindexedIds = [];
+			for (const id of messageIds) {
+				const indexed = await this.db.getByKey({
+					tableName: TABLE_MESSAGES,
+					key: getMessageIndexKey(id)
+				});
+				if (!indexed?.threadId) {
+					unindexedIds.push(id);
+					continue;
+				}
+				const message = await this.db.getByKey({
+					tableName: TABLE_MESSAGES,
+					key: getMessageKey(indexed.threadId, id)
+				});
+				if (message) rawMessages.push(message);
+				else unindexedIds.push(id);
+			}
+			if (unindexedIds.length > 0) {
+				const allMessages = await this.listAllMessages();
+				const unindexedSet = new Set(unindexedIds);
+				const foundMessages = allMessages.filter((msg) => unindexedSet.has(msg.id));
+				rawMessages.push(...foundMessages);
+				if (foundMessages.length > 0) await this.db.bulkSet({
+					tableName: TABLE_MESSAGES,
+					entries: foundMessages.filter((msg) => msg.threadId).map((msg) => ({
+						key: getMessageIndexKey(msg.id),
+						value: { threadId: msg.threadId }
+					}))
+				});
+			}
+			return { messages: new MessageList().add(rawMessages.map(this.parseStoredMessage), "memory").get.all.db() };
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "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("ELASTICSEARCH", "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("ELASTICSEARCH", "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
+			};
+			let messagesData = [];
+			for (const tid of threadIds) {
+				const threadMessages = await this.listThreadMessages(tid);
+				messagesData.push(...threadMessages.map(this.parseStoredMessage));
+			}
+			if (messagesData.length === 0) return {
+				messages: [],
+				total: 0,
+				page,
+				perPage: perPageForResponse,
+				hasMore: false
+			};
+			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("ELASTICSEARCH", "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 resource = await this.db.getByKey({
+				tableName: TABLE_RESOURCES,
+				key: `${TABLE_RESOURCES}:${resourceId}`
+			});
+			if (!resource) return null;
+			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 serializedResource = {
+				...resource,
+				metadata: JSON.stringify(resource.metadata),
+				createdAt: resource.createdAt.toISOString(),
+				updatedAt: resource.updatedAt.toISOString()
+			};
+			await this.db.set({
+				tableName: TABLE_RESOURCES,
+				key: `${TABLE_RESOURCES}:${resource.id}`,
+				value: 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 allMessages = await this.listAllMessages();
+			const existingMessages = [];
+			const messageIdToKey = {};
+			for (const messageId of messageIds) {
+				const message = allMessages.find((msg) => msg.id === messageId);
+				if (message?.threadId) {
+					existingMessages.push(message);
+					messageIdToKey[messageId] = getMessageKey(message.threadId, messageId);
+				}
+			}
+			if (existingMessages.length === 0) return [];
+			const threadIdsToUpdate = /* @__PURE__ */ new Set();
+			const keysToDelete = [];
+			const entries = [];
+			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) {
+					keysToDelete.push(key);
+					const newKey = getMessageKey(updatePayload.threadId, id);
+					entries.push({
+						key: newKey,
+						value: updatedMessage
+					});
+					entries.push({
+						key: getMessageIndexKey(id),
+						value: { threadId: updatePayload.threadId }
+					});
+					messageIdToKey[id] = newKey;
+					continue;
+				}
+				entries.push({
+					key,
+					value: updatedMessage
+				});
+			}
+			const now = /* @__PURE__ */ new Date();
+			const threadEntries = [];
+			for (const threadId of threadIdsToUpdate) if (threadId) {
+				const existingThread = await this.db.get({
+					tableName: TABLE_THREADS,
+					keys: { id: threadId }
+				});
+				if (existingThread) {
+					const updatedThread = {
+						...existingThread,
+						updatedAt: now
+					};
+					threadEntries.push({
+						key: getKey(TABLE_THREADS, { id: threadId }),
+						value: processRecord(TABLE_THREADS, updatedThread).processedRecord
+					});
+				}
+			}
+			await this.db.deleteMany({
+				tableName: TABLE_MESSAGES,
+				keys: keysToDelete
+			});
+			await this.db.bulkSet({
+				tableName: TABLE_MESSAGES,
+				entries
+			});
+			await this.db.bulkSet({
+				tableName: TABLE_THREADS,
+				entries: threadEntries
+			});
+			const updatedMessages = [];
+			for (const messageId of messageIds) {
+				const key = messageIdToKey[messageId];
+				if (key) {
+					const message = await this.db.getByKey({
+						tableName: TABLE_MESSAGES,
+						key
+					});
+					if (message) updatedMessages.push(message);
+				}
+			}
+			return updatedMessages;
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "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 allMessages = await this.listAllMessages();
+			const idsToDelete = new Set(messageIds);
+			const threadIds = /* @__PURE__ */ new Set();
+			const keysToDelete = [];
+			for (const message of allMessages) {
+				if (!idsToDelete.has(message.id) || !message.threadId) continue;
+				keysToDelete.push(getMessageKey(message.threadId, message.id));
+				keysToDelete.push(getMessageIndexKey(message.id));
+				threadIds.add(message.threadId);
+			}
+			if (keysToDelete.length === 0) return;
+			await this.db.deleteMany({
+				tableName: TABLE_MESSAGES,
+				keys: keysToDelete
+			});
+			const threadEntries = [];
+			for (const threadId of threadIds) {
+				const thread = await this.db.get({
+					tableName: TABLE_THREADS,
+					keys: { id: threadId }
+				});
+				if (!thread) continue;
+				const updatedThread = {
+					...thread,
+					updatedAt: /* @__PURE__ */ new Date()
+				};
+				threadEntries.push({
+					key: getKey(TABLE_THREADS, { id: threadId }),
+					value: processRecord(TABLE_THREADS, updatedThread).processedRecord
+				});
+			}
+			await this.db.bulkSet({
+				tableName: TABLE_THREADS,
+				entries: threadEntries
+			});
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "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("ELASTICSEARCH", "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("ELASTICSEARCH", "CLONE_THREAD", "THREAD_EXISTS"),
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			text: `Thread with id ${newThreadId} already exists`,
+			details: { newThreadId }
+		});
+		try {
+			let sourceMessages = (await this.listThreadMessages(sourceThreadId)).map((msg) => ({
+				...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 clonedMessages = [];
+			const targetResourceId = resourceId || sourceThread.resourceId;
+			const entries = [];
+			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
+				};
+				entries.push({
+					key: getMessageKey(newThreadId, newMessageId),
+					value: {
+						...newMessage,
+						_index: i
+					}
+				});
+				entries.push({
+					key: getMessageIndexKey(newMessageId),
+					value: { threadId: newThreadId }
+				});
+				clonedMessages.push(newMessage);
+			}
+			await this.db.insert({
+				tableName: TABLE_THREADS,
+				record: newThread
+			});
+			await this.db.bulkSet({
+				tableName: TABLE_MESSAGES,
+				entries
+			});
+			return {
+				thread: newThread,
+				clonedMessages
+			};
+		} catch (error) {
+			if (error instanceof MastraError) throw error;
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "CLONE_THREAD", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					sourceThreadId,
+					newThreadId
+				}
+			}, error);
+		}
+	}
+};
+function threadMessagesPrefix(threadId) {
+	return `${TABLE_MESSAGES}:threadId:${threadId}:id:`;
+}
+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 ScoresElasticSearch = class extends ScoresStorage {
+	db;
+	constructor(config) {
+		super();
+		this.db = new ElasticSearchDB({ 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("ELASTICSEARCH", "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("ELASTICSEARCH", "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.db.set({
+				tableName: TABLE_SCORERS,
+				key,
+				value: processedRecord
+			});
+			return { score: {
+				...validatedScore,
+				id,
+				createdAt: now,
+				updatedAt: now
+			} };
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "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 filtered = (await this.db.listAll({ tableName: TABLE_SCORERS })).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 WorkflowsElasticSearch = class extends WorkflowsStorage {
+	db;
+	constructor(config) {
+		super();
+		this.db = new ElasticSearchDB({ 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("ELASTICSEARCH", "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("ELASTICSEARCH", "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("ELASTICSEARCH", "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;
+		try {
+			return (await this.db.get({
+				tableName: TABLE_WORKFLOW_SNAPSHOT,
+				keys: {
+					namespace,
+					workflow_name: workflowName,
+					run_id: runId
+				}
+			}))?.snapshot ?? null;
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "LOAD_WORKFLOW_SNAPSHOT", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					namespace,
+					workflowName,
+					runId
+				}
+			}, error);
+		}
+	}
+	async getWorkflowRunById({ runId, workflowName }) {
+		try {
+			const data = (await this.db.listAll({
+				tableName: TABLE_WORKFLOW_SNAPSHOT,
+				keyPrefix: getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows" })
+			})).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("ELASTICSEARCH", "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.db.delete({
+				tableName: TABLE_WORKFLOW_SNAPSHOT,
+				key
+			});
+		} catch (error) {
+			throw new MastraError({
+				id: createStorageErrorId("ELASTICSEARCH", "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("ELASTICSEARCH", "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 keyPrefix = getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace: "workflows" });
+			if (workflowName) keyPrefix = getKey(TABLE_WORKFLOW_SNAPSHOT, {
+				namespace: "workflows",
+				workflow_name: workflowName
+			}) + ":";
+			let runs = (await this.db.listAll({
+				tableName: TABLE_WORKFLOW_SNAPSHOT,
+				keyPrefix
+			})).filter((record) => record !== null && record !== void 0 && typeof record === "object" && "workflow_name" in record).filter((record) => !workflowName || record.workflow_name === workflowName).filter((record) => !resourceId || record.resourceId === resourceId).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("ELASTICSEARCH", "LIST_WORKFLOW_RUNS", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					namespace: "workflows",
+					workflowName: workflowName || "",
+					resourceId: resourceId || ""
+				}
+			}, error);
+		}
+	}
+};
+//#endregion
+//#region src/storage/store.ts
+/**
+* ElasticSearch storage adapter for Mastra.
+*
+* Implements the memory, workflows, and scores storage domains on top of
+* ElasticSearch. Shares the same connection config surface as
+* `ElasticSearchVector`, so both can reuse one client or connection config.
+*
+* @example
+* ```typescript
+* // Using connection parameters
+* const storage = new ElasticSearchStore({
+*   id: 'my-store',
+*   url: 'http://localhost:9200',
+*   auth: { apiKey: '...' },
+* });
+*
+* // Access memory domain
+* const memory = await storage.getStore('memory');
+* await memory?.saveThread({ thread });
+* ```
+*
+* @example
+* ```typescript
+* // Using a pre-configured client shared with ElasticSearchVector
+* import { Client } from '@elastic/elasticsearch';
+*
+* const client = new Client({ node: 'http://localhost:9200' });
+* const storage = new ElasticSearchStore({ id: 'my-store', client });
+* const vector = new ElasticSearchVector({ id: 'my-vector', client });
+* ```
+*/
+var ElasticSearchStore = class extends MastraStorage {
+	client;
+	shouldManageConnection;
+	stores;
+	constructor(config) {
+		super({
+			id: config.id,
+			name: "ElasticSearch",
+			disableInit: config.disableInit
+		});
+		if ("client" in config && config.client) {
+			this.client = config.client;
+			this.shouldManageConnection = false;
+		} else if ("url" in config && config.url) {
+			this.client = new Client({
+				node: config.url,
+				...config.auth && { auth: config.auth },
+				name: "mastra-elasticsearch",
+				headers: { "user-agent": `mastra-es/${version}` }
+			});
+			this.shouldManageConnection = true;
+		} else throw new MastraError({
+			id: "ELASTIC_SEARCH_STORE_CONSTRUCTOR_ERROR",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			text: "Invalid config: provide either { client } or { url }."
+		});
+		this.stores = {
+			memory: new MemoryElasticSearch({ client: this.client }),
+			workflows: new WorkflowsElasticSearch({ client: this.client }),
+			scores: new ScoresElasticSearch({ client: this.client })
+		};
+	}
+	getClient() {
+		return this.client;
+	}
+	async close() {
+		if (this.shouldManageConnection) await this.client.close();
+	}
+};
+//#endregion
+export { ElasticSearchStore, ElasticSearchVector, MemoryElasticSearch, ScoresElasticSearch, WorkflowsElasticSearch };
 
 //# sourceMappingURL=index.js.map