@mastra/mongodb 1.20.1 → 1.22.0-alpha.0

package/dist/index.js

@@ -8,7 +8,7 @@ import { MessageList } from "@mastra/core/agent";
 import { saveScorePayloadSchema } from "@mastra/core/evals";
 import { skillSnapshotFieldValuesEqual } from "@mastra/core/storage/domains/skills";
 //#region package.json
-var version = "1.20.1";
+var version = "1.22.0-alpha.0";
 //#endregion
 //#region src/vector/filter.ts
 /**
@@ -84,11 +84,22 @@ var MongoDBFilterTranslator = class extends BaseFilterTranslator {
 function describeEmbedding(config) {
 	return config ? `autoEmbed (path "${config.path}", model "${config.model}")` : "client-side vectors";
 }
+/**
+* Whether Atlas refused a `$vectorSearch` because the index is still in its initial sync. The
+* server reports it as a generic `UnknownError`, so the state named in the message is the only
+* thing that tells it apart from other failures with the same code.
+*/
+function isInitialSyncError(error) {
+	const message = error?.message;
+	return typeof message === "string" && message.includes("while in state INITIAL_SYNC");
+}
 var MongoDBVector = class MongoDBVector extends MastraVector {
 	client;
 	db;
 	collections;
 	embeddingFieldName;
+	/** Automated Embedding defaults applied to indexes created without their own config. */
+	defaultAutoEmbed;
 	metadataFieldName = "metadata";
 	documentFieldName = "document";
 	/**
@@ -124,6 +135,19 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 	*/
 	static REGISTRY_COLLECTION = "__mastra_vector_indexes__";
 	/**
+	* Waits between attempts while a queried index is in INITIAL_SYNC, about six seconds in all.
+	* On a live Atlas cluster the window lasted around two seconds for both a regular and an
+	* autoEmbed index; the budget leaves room for a slower build without holding a failing query
+	* for long.
+	*/
+	static INITIAL_SYNC_RETRY_DELAYS_MS = [
+		250,
+		500,
+		1e3,
+		2e3,
+		2e3
+	];
+	/**
 	* MongoDB query operators supported inside `$vectorSearch.filter`. Intentionally
 	* conservative: filters using any operator outside this set fall back to the
 	* `$match` pre-filter, which supports the full query language. Widening this set
@@ -146,7 +170,7 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 		euclidean: "euclidean",
 		dotproduct: "dotProduct"
 	};
-	constructor({ id, uri, dbName, options, embeddingFieldPath }) {
+	constructor({ id, uri, dbName, options, embeddingFieldPath, autoEmbed }) {
 		super({ id });
 		if (!uri) throw new Error("MongoDBVector requires a connection string. Provide \"uri\" in the constructor options.");
 		const client = new MongoClient(uri, {
@@ -160,6 +184,11 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 		this.db = this.client.db(dbName);
 		this.collections = /* @__PURE__ */ new Map();
 		this.embeddingFieldName = embeddingFieldPath ?? "embedding";
+		this.defaultAutoEmbed = autoEmbed;
+	}
+	/** True once the store is configured with Automated Embedding defaults. */
+	get isSelfEmbedding() {
+		return this.defaultAutoEmbed !== void 0;
 	}
 	/**
 	* Resolve the collection + vector-index names for an index, honoring BYO overrides.
@@ -441,7 +470,8 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 	* "index not found" or "index not ready" errors on subsequent operations.
 	*/
 	async createIndex(params) {
-		const { indexName, dimension, metric = "cosine", filterFields, collectionName, searchIndexName, allowWrites, autoEmbed } = params;
+		const { indexName, dimension, metric = "cosine", filterFields, collectionName, searchIndexName, allowWrites, autoEmbed: autoEmbedParam } = params;
+		const autoEmbed = autoEmbedParam ?? (dimension === void 0 ? this.defaultAutoEmbed : void 0);
 		let mongoMetric;
 		try {
 			if (autoEmbed) {
@@ -1029,7 +1059,7 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 				vectorSearch.filter = pushed.length > 1 ? { $and: pushed } : pushed[0];
 			}
 			const pipeline = [{ $vectorSearch: vectorSearch }, ...this.buildProjection(metadataMode, includeVector, "vectorSearchScore", autoEmbed?.path)];
-			return (await collection.aggregate(pipeline).toArray()).map((result) => ({
+			return (await this.aggregateVectorSearch(collection, pipeline)).map((result) => ({
 				id: this.idToString(result._id),
 				score: result.score,
 				metadata: result.metadata,
@@ -1046,6 +1076,24 @@ var MongoDBVector = class MongoDBVector extends MastraVector {
 		}
 	}
 	/**
+	* Runs a `$vectorSearch` pipeline, retrying while the index is in INITIAL_SYNC.
+	*
+	* While Atlas first builds a vector search index it usually answers with an empty result, but
+	* for a few seconds it fails with "cannot query vector index ... while in state INITIAL_SYNC"
+	* instead. A caller that creates an index and queries it straight away, as `Memory` does on a
+	* fresh database, can land in that window. Any other error, and an INITIAL_SYNC that outlasts
+	* the retry budget, is thrown unchanged.
+	*/
+	async aggregateVectorSearch(collection, pipeline) {
+		for (const delayMs of MongoDBVector.INITIAL_SYNC_RETRY_DELAYS_MS) try {
+			return await collection.aggregate(pipeline).toArray();
+		} catch (error) {
+			if (!isInitialSyncError(error)) throw error;
+			await new Promise((resolve) => setTimeout(resolve, delayMs));
+		}
+		return collection.aggregate(pipeline).toArray();
+	}
+	/**
 	* Lists LOGICAL Mastra index names, not physical collection names.
 	*
 	* Returns the union of:
@@ -6464,6 +6512,7 @@ const OM_TABLE = "mastra_observational_memory";
 var MemoryStorageMongoDB = class MemoryStorageMongoDB extends MemoryStorage {
 	supportsPartialThreadUpdate = true;
 	supportsObservationalMemory = true;
+	supportsObservationalMemoryHistorySearch = true;
 	#connector;
 	#skipDefaultIndexes;
 	#indexes;
@@ -6699,8 +6748,11 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends MemoryStorage {
 			if (!target) continue;
 			const prevMessages = await collection.find({
 				thread_id: target.threadId,
-				createdAt: { $lte: target.createdAt },
-				...resourceFilter
+				...resourceFilter,
+				$or: [{ createdAt: { $lt: target.createdAt } }, {
+					createdAt: target.createdAt,
+					id: { $lte: id }
+				}]
 			}).sort({
 				createdAt: -1,
 				id: -1
@@ -6709,8 +6761,11 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends MemoryStorage {
 			if (withNextMessages > 0) {
 				const nextMessages = await collection.find({
 					thread_id: target.threadId,
-					createdAt: { $gt: target.createdAt },
-					...resourceFilter
+					...resourceFilter,
+					$or: [{ createdAt: { $gt: target.createdAt } }, {
+						createdAt: target.createdAt,
+						id: { $gt: id }
+					}]
 				}).sort({
 					createdAt: 1,
 					id: 1
@@ -7504,13 +7559,34 @@ var MemoryStorageMongoDB = class MemoryStorageMongoDB extends MemoryStorage {
 			const lookupKey = this.getOMKey(threadId, resourceId);
 			const collection = await this.getCollection(OM_TABLE);
 			const filter = { lookupKey };
+			if (options?.recordId !== void 0) filter["id"] = options.recordId;
 			if (options?.from || options?.to) {
 				const createdAtFilter = {};
 				if (options.from) createdAtFilter["$gte"] = options.from;
 				if (options.to) createdAtFilter["$lte"] = options.to;
 				filter["createdAt"] = createdAtFilter;
 			}
-			let cursor = collection.find(filter).sort({ generationCount: -1 });
+			if (options?.groupId !== void 0) {
+				const prefix = { $literal: `<observation-group id="${options.groupId}"` };
+				filter["$expr"] = { $or: [{ $gte: [{ $indexOfCP: [{ $ifNull: ["$activeObservations", ""] }, prefix] }, 0] }, { $anyElementTrue: [{ $map: {
+					input: { $cond: [
+						{ $isArray: "$bufferedObservationChunks" },
+						"$bufferedObservationChunks",
+						[]
+					] },
+					as: "chunk",
+					in: { $gte: [{ $indexOfCP: [{ $ifNull: ["$$chunk.observations", ""] }, prefix] }, 0] }
+				} }] }] };
+			}
+			if (options?.beforeGeneration !== void 0 || options?.afterGeneration !== void 0) filter["generationCount"] = {
+				...options.beforeGeneration !== void 0 ? { $lt: options.beforeGeneration } : {},
+				...options.afterGeneration !== void 0 ? { $gt: options.afterGeneration } : {}
+			};
+			let cursor = collection.find(filter).sort({
+				generationCount: options?.sortDirection === "ASC" ? 1 : -1,
+				createdAt: 1,
+				id: 1
+			});
 			if (options?.offset != null) cursor = cursor.skip(options.offset);
 			return (await cursor.limit(limit).toArray()).map((doc) => this.parseOMDocument(doc));
 		} catch (error) {