@mastra/convex 1.4.0 → 1.5.0

package/dist/server-13j_f22k.cjs

@@ -0,0 +1,1882 @@
+require("./schema.cjs");
+let convex_server = require("convex/server");
+let _mastra_core_storage_constants = require("@mastra/core/storage/constants");
+let convex_values = require("convex/values");
+//#region src/server/cache.ts
+const CACHE_TABLE = "mastra_cache";
+const CACHE_LIST_TABLE = "mastra_cache_list_items";
+const CACHE_MUTATION_BATCH_SIZE = 25;
+function encodeValue(value) {
+	return JSON.stringify(value === void 0 ? null : value);
+}
+function decodeValue(value) {
+	return JSON.parse(value);
+}
+function isExpired(doc, now) {
+	return doc.expiresAt !== null && doc.expiresAt <= now;
+}
+function normalizeListRange(from, to, length) {
+	const normalizedFrom = from < 0 ? Math.max(length + from, 0) : from;
+	const normalizedTo = to < 0 ? length + to : to;
+	if (normalizedTo < normalizedFrom || normalizedFrom >= length) return null;
+	return {
+		from: normalizedFrom,
+		to: normalizedTo
+	};
+}
+async function findCacheDoc(ctx, key) {
+	return await ctx.db.query(CACHE_TABLE).withIndex("by_key", (q) => q.eq("key", key)).first();
+}
+async function deleteCacheKey(ctx, key) {
+	const [doc, listItems] = await Promise.all([findCacheDoc(ctx, key), ctx.db.query(CACHE_LIST_TABLE).withIndex("by_key_index", (q) => q.eq("key", key)).take(26)]);
+	if (doc && doc.kind !== "deleted") await ctx.db.patch(doc._id, { kind: "deleted" });
+	for (const item of listItems.slice(0, CACHE_MUTATION_BATCH_SIZE)) await ctx.db.delete(item._id);
+	const hasMore = listItems.length > CACHE_MUTATION_BATCH_SIZE;
+	if (doc && !hasMore) await ctx.db.delete(doc._id);
+	return { hasMore };
+}
+async function getLiveCacheDoc(ctx, key, now) {
+	const doc = await findCacheDoc(ctx, key);
+	if (!doc) return {
+		doc: null,
+		hasMore: false
+	};
+	if (doc.kind === "deleted") return {
+		doc: null,
+		hasMore: (await deleteCacheKey(ctx, key)).hasMore
+	};
+	if (!isExpired(doc, now)) return {
+		doc,
+		hasMore: false
+	};
+	return {
+		doc: null,
+		hasMore: (await deleteCacheKey(ctx, key)).hasMore
+	};
+}
+async function writeCacheDoc(ctx, key, existing, patch) {
+	if (existing) {
+		await ctx.db.patch(existing._id, patch);
+		return {
+			...existing,
+			...patch
+		};
+	}
+	return {
+		_id: await ctx.db.insert(CACHE_TABLE, {
+			key,
+			...patch
+		}),
+		key,
+		...patch
+	};
+}
+async function clearPrefix(ctx, keyPrefix) {
+	const [docs, orphanListItems] = await Promise.all([ctx.db.query(CACHE_TABLE).withIndex("by_key_prefix", (q) => q.eq("keyPrefix", keyPrefix)).take(26), ctx.db.query(CACHE_LIST_TABLE).withIndex("by_key_prefix", (q) => q.eq("keyPrefix", keyPrefix)).take(1)]);
+	if (docs.length > 0) {
+		for (const doc of docs.slice(0, CACHE_MUTATION_BATCH_SIZE)) {
+			if (doc.kind === "list" || doc.kind === "deleted") return (await deleteCacheKey(ctx, doc.key)).hasMore || docs.length > 1 || orphanListItems.length > 0;
+			await ctx.db.delete(doc._id);
+		}
+		return docs.length > CACHE_MUTATION_BATCH_SIZE || orphanListItems.length > 0;
+	}
+	const listItems = await ctx.db.query(CACHE_LIST_TABLE).withIndex("by_key_prefix", (q) => q.eq("keyPrefix", keyPrefix)).take(26);
+	for (const item of listItems.slice(0, CACHE_MUTATION_BATCH_SIZE)) await ctx.db.delete(item._id);
+	return listItems.length > CACHE_MUTATION_BATCH_SIZE;
+}
+async function handleCacheOperation(ctx, request) {
+	const now = Date.now();
+	switch (request.op) {
+		case "get": {
+			const { doc, hasMore } = await getLiveCacheDoc(ctx, request.key, now);
+			if (hasMore) return {
+				ok: true,
+				result: null,
+				hasMore: true
+			};
+			if (!doc || doc.kind !== "value") return {
+				ok: true,
+				result: null
+			};
+			return {
+				ok: true,
+				result: decodeValue(doc.value ?? "null")
+			};
+		}
+		case "set": {
+			let existing = await findCacheDoc(ctx, request.key);
+			if (existing && (isExpired(existing, now) || existing.kind !== "value")) {
+				if ((await deleteCacheKey(ctx, request.key)).hasMore) return {
+					ok: true,
+					hasMore: true
+				};
+				existing = null;
+			}
+			await writeCacheDoc(ctx, request.key, existing, {
+				keyPrefix: request.keyPrefix,
+				kind: "value",
+				value: encodeValue(request.value),
+				expiresAt: request.expiresAt
+			});
+			return { ok: true };
+		}
+		case "listLength": {
+			const { doc, hasMore } = await getLiveCacheDoc(ctx, request.key, now);
+			if (hasMore) return {
+				ok: true,
+				result: 0,
+				hasMore: true
+			};
+			if (!doc) return {
+				ok: true,
+				result: 0
+			};
+			if (doc.kind !== "list") return {
+				ok: false,
+				error: `${request.key} exists but is not an array`
+			};
+			return {
+				ok: true,
+				result: doc.counter ?? 0
+			};
+		}
+		case "listPush": {
+			let existing = await findCacheDoc(ctx, request.key);
+			if (existing && (isExpired(existing, now) || existing.kind === "deleted")) {
+				if ((await deleteCacheKey(ctx, request.key)).hasMore) return {
+					ok: true,
+					hasMore: true
+				};
+				existing = null;
+			}
+			if (existing && existing.kind !== "list") return {
+				ok: false,
+				error: `${request.key} exists but is not an array`
+			};
+			const doc = existing ? await writeCacheDoc(ctx, request.key, existing, {
+				kind: "list",
+				keyPrefix: request.keyPrefix,
+				counter: (existing.counter ?? 0) + 1,
+				expiresAt: request.expiresAt
+			}) : await writeCacheDoc(ctx, request.key, null, {
+				kind: "list",
+				keyPrefix: request.keyPrefix,
+				counter: 1,
+				expiresAt: request.expiresAt
+			});
+			await ctx.db.insert(CACHE_LIST_TABLE, {
+				key: request.key,
+				keyPrefix: request.keyPrefix,
+				index: (doc.counter ?? 1) - 1,
+				value: encodeValue(request.value)
+			});
+			return { ok: true };
+		}
+		case "listFromTo": {
+			const { doc, hasMore } = await getLiveCacheDoc(ctx, request.key, now);
+			if (hasMore) return {
+				ok: true,
+				result: [],
+				hasMore: true
+			};
+			if (!doc || doc.kind !== "list") return {
+				ok: true,
+				result: []
+			};
+			const range = normalizeListRange(request.from, request.to, doc.counter ?? 0);
+			if (!range) return {
+				ok: true,
+				result: []
+			};
+			return {
+				ok: true,
+				result: (await ctx.db.query(CACHE_LIST_TABLE).withIndex("by_key_index", (q) => {
+					return q.eq("key", request.key).gte("index", range.from).lte("index", range.to);
+				}).collect()).map((item) => decodeValue(item.value))
+			};
+		}
+		case "delete": return {
+			ok: true,
+			hasMore: (await deleteCacheKey(ctx, request.key)).hasMore
+		};
+		case "clear": return {
+			ok: true,
+			hasMore: await clearPrefix(ctx, request.keyPrefix)
+		};
+		case "increment": {
+			let existing = await findCacheDoc(ctx, request.key);
+			if (existing && (isExpired(existing, now) || existing.kind === "deleted")) {
+				if ((await deleteCacheKey(ctx, request.key)).hasMore) return {
+					ok: true,
+					hasMore: true
+				};
+				existing = null;
+			}
+			if (existing && existing.kind !== "counter") return {
+				ok: false,
+				error: `${request.key} exists but is not a number`
+			};
+			const nextCounter = (existing?.counter ?? 0) + 1;
+			await writeCacheDoc(ctx, request.key, existing, {
+				kind: "counter",
+				keyPrefix: request.keyPrefix,
+				counter: nextCounter,
+				expiresAt: request.expiresAt
+			});
+			return {
+				ok: true,
+				result: nextCounter
+			};
+		}
+	}
+	return {
+		ok: false,
+		error: `Unsupported operation ${request.op}`
+	};
+}
+const mastraCache = (0, convex_server.mutationGeneric)(async (ctx, request) => handleCacheOperation(ctx, request));
+//#endregion
+//#region src/server/index-map.ts
+const TABLE_INDEX_MAP = {
+	mastra_messages: [
+		{
+			name: "by_thread_created",
+			fields: ["thread_id", "createdAt"]
+		},
+		{
+			name: "by_thread",
+			fields: ["thread_id"]
+		},
+		{
+			name: "by_resource",
+			fields: ["resourceId"]
+		},
+		{
+			name: "by_record_id",
+			fields: ["id"]
+		}
+	],
+	mastra_threads: [
+		{
+			name: "by_resource",
+			fields: ["resourceId"]
+		},
+		{
+			name: "by_created",
+			fields: ["createdAt"]
+		},
+		{
+			name: "by_updated",
+			fields: ["updatedAt"]
+		},
+		{
+			name: "by_record_id",
+			fields: ["id"]
+		}
+	],
+	mastra_resources: [{
+		name: "by_updated",
+		fields: ["updatedAt"]
+	}, {
+		name: "by_record_id",
+		fields: ["id"]
+	}],
+	mastra_workflow_snapshots: [
+		{
+			name: "by_workflow_run",
+			fields: ["workflow_name", "run_id"]
+		},
+		{
+			name: "by_workflow",
+			fields: ["workflow_name"]
+		},
+		{
+			name: "by_resource",
+			fields: ["resourceId"]
+		},
+		{
+			name: "by_created",
+			fields: ["createdAt"]
+		},
+		{
+			name: "by_record_id",
+			fields: ["id"]
+		}
+	],
+	mastra_scorers: [
+		{
+			name: "by_entity",
+			fields: ["entityId", "entityType"]
+		},
+		{
+			name: "by_scorer",
+			fields: ["scorerId"]
+		},
+		{
+			name: "by_run",
+			fields: ["runId"]
+		},
+		{
+			name: "by_created",
+			fields: ["createdAt"]
+		},
+		{
+			name: "by_record_id",
+			fields: ["id"]
+		}
+	],
+	mastra_schedules: [
+		{
+			name: "by_workflow_status",
+			fields: ["workflow_id", "status"]
+		},
+		{
+			name: "by_workflow_id",
+			fields: ["workflow_id"]
+		},
+		{
+			name: "by_owner",
+			fields: ["owner_type", "owner_id"]
+		},
+		{
+			name: "by_owner_id",
+			fields: ["owner_id"]
+		},
+		{
+			name: "by_status_next_fire_at",
+			fields: ["status", "next_fire_at"]
+		},
+		{
+			name: "by_created",
+			fields: ["created_at"]
+		},
+		{
+			name: "by_record_id",
+			fields: ["id"]
+		}
+	],
+	mastra_schedule_triggers: [
+		{
+			name: "by_schedule_actual",
+			fields: ["schedule_id", "actual_fire_at"]
+		},
+		{
+			name: "by_parent_trigger",
+			fields: ["parent_trigger_id"]
+		},
+		{
+			name: "by_record_id",
+			fields: ["id"]
+		}
+	],
+	mastra_channel_installations: [
+		{
+			name: "by_platform_agent",
+			fields: ["platform", "agentId"]
+		},
+		{
+			name: "by_webhook",
+			fields: ["webhookId"]
+		},
+		{
+			name: "by_platform",
+			fields: ["platform"]
+		},
+		{
+			name: "by_record_id",
+			fields: ["id"]
+		}
+	],
+	mastra_channel_config: [{
+		name: "by_platform",
+		fields: ["platform"]
+	}, {
+		name: "by_record_id",
+		fields: ["id"]
+	}],
+	mastra_background_tasks: [
+		{
+			name: "by_agent_status",
+			fields: ["agent_id", "status"]
+		},
+		{
+			name: "by_status_created",
+			fields: ["status", "createdAt"]
+		},
+		{
+			name: "by_run",
+			fields: ["run_id"]
+		},
+		{
+			name: "by_tool_call",
+			fields: ["tool_call_id"]
+		},
+		{
+			name: "by_thread",
+			fields: ["thread_id"]
+		},
+		{
+			name: "by_resource",
+			fields: ["resource_id"]
+		},
+		{
+			name: "by_tool",
+			fields: ["tool_name"]
+		},
+		{
+			name: "by_created",
+			fields: ["createdAt"]
+		},
+		{
+			name: "by_record_id",
+			fields: ["id"]
+		}
+	],
+	mastra_vector_indexes: [{
+		name: "by_name",
+		fields: ["indexName"]
+	}, {
+		name: "by_record_id",
+		fields: ["id"]
+	}],
+	mastra_observational_memory: [{
+		name: "by_lookup_key",
+		fields: ["lookupKey", "generationCount"]
+	}, {
+		name: "by_record_id",
+		fields: ["id"]
+	}]
+};
+/**
+* Finds the best matching index for the given equality filters on a Convex table.
+*
+* Returns the index name and the subset of filters that form the index prefix,
+* or null when no index matches.
+*
+* The "best" index is the one whose prefix has the most consecutive fields
+* covered by the provided filters. For example, given filters for `thread_id`
+* and `createdAt` on mastra_messages, the composite `by_thread_created` index
+* (fields: [thread_id, createdAt]) is preferred over `by_thread` (fields: [thread_id]).
+*/
+function findBestIndex(convexTable, filters) {
+	const indexes = TABLE_INDEX_MAP[convexTable];
+	if (!indexes || filters.length === 0) return null;
+	const filtersByField = /* @__PURE__ */ new Map();
+	for (const f of filters) filtersByField.set(f.field, f);
+	let best = null;
+	for (const index of indexes) {
+		let prefixLength = 0;
+		const indexedFilters = [];
+		for (const field of index.fields) {
+			const filter = filtersByField.get(field);
+			if (filter) {
+				prefixLength++;
+				indexedFilters.push(filter);
+			} else break;
+		}
+		if (prefixLength > 0 && (!best || prefixLength > best.prefixLength)) best = {
+			indexName: index.name,
+			indexedFilters,
+			prefixLength
+		};
+	}
+	return best ? {
+		indexName: best.indexName,
+		indexedFilters: best.indexedFilters
+	} : null;
+}
+//#endregion
+//#region src/server/observational-memory.ts
+const OM_QUERY_MAX_DOCS = 1e4;
+/**
+* Parse the stored bufferedObservationChunks JSON string. Tolerates null,
+* missing, and malformed values by returning an empty array.
+*/
+function parseStoredChunks(value) {
+	if (typeof value !== "string" || !value) return [];
+	try {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) ? parsed : [];
+	} catch {
+		return [];
+	}
+}
+/**
+* Select how many buffered chunks to activate.
+*
+* Finds the chunk boundary closest to the activation target, biased over
+* (prefer removing slightly more than the target so remaining context lands at
+* or below the retention floor), with an overshoot safeguard that falls back
+* to the best under boundary. Ported from the core in-memory reference.
+*/
+function selectActivationBoundary(chunks, opts) {
+	const retentionFloor = opts.messageTokensThreshold * (1 - opts.activationRatio);
+	const targetMessageTokens = Math.max(0, opts.currentPendingTokens - retentionFloor);
+	let cumulativeMessageTokens = 0;
+	let bestOverBoundary = 0;
+	let bestOverTokens = 0;
+	let bestUnderBoundary = 0;
+	let bestUnderTokens = 0;
+	for (let i = 0; i < chunks.length; i++) {
+		cumulativeMessageTokens += chunks[i].messageTokens ?? 0;
+		const boundary = i + 1;
+		if (cumulativeMessageTokens >= targetMessageTokens) {
+			if (bestOverBoundary === 0 || cumulativeMessageTokens < bestOverTokens) {
+				bestOverBoundary = boundary;
+				bestOverTokens = cumulativeMessageTokens;
+			}
+		} else if (cumulativeMessageTokens > bestUnderTokens) {
+			bestUnderBoundary = boundary;
+			bestUnderTokens = cumulativeMessageTokens;
+		}
+	}
+	const maxOvershoot = retentionFloor * .95;
+	const overshoot = bestOverTokens - targetMessageTokens;
+	const remainingAfterOver = opts.currentPendingTokens - bestOverTokens;
+	const remainingAfterUnder = opts.currentPendingTokens - bestUnderTokens;
+	const minRemaining = Math.min(1e3, retentionFloor);
+	if (opts.forceMaxActivation && bestOverBoundary > 0 && remainingAfterOver >= minRemaining) return bestOverBoundary;
+	if (bestOverBoundary > 0 && overshoot <= maxOvershoot && remainingAfterOver >= minRemaining) return bestOverBoundary;
+	if (bestUnderBoundary > 0 && remainingAfterUnder >= minRemaining) return bestUnderBoundary;
+	if (bestOverBoundary > 0) return bestOverBoundary;
+	return 1;
+}
+/**
+* Merge a buffered reflection with the observations added after the reflection
+* started. Lines 0..reflectedLineCount of activeObservations were reflected on
+* and are replaced by the reflection; later lines are appended as-is.
+*/
+function mergeReflectionWithUnreflected(activeObservations, bufferedReflection, reflectedLineCount) {
+	const unreflectedContent = (activeObservations || "").split("\n").slice(reflectedLineCount).join("\n").trim();
+	return unreflectedContent ? `${bufferedReflection}\n\n${unreflectedContent}` : bufferedReflection;
+}
+function isPlainObj(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Deep-merge two plain config objects (source wins; undefined source values
+* are skipped). Mirrors MemoryStorage.deepMergeConfig in @mastra/core.
+*/
+function deepMergeOMConfig(target, source) {
+	const output = { ...target };
+	for (const key of Object.keys(source)) {
+		const tVal = target[key];
+		const sVal = source[key];
+		if (isPlainObj(tVal) && isPlainObj(sVal)) output[key] = deepMergeOMConfig(tVal, sVal);
+		else if (sVal !== void 0) output[key] = sVal;
+	}
+	return output;
+}
+function parseJsonObject(value) {
+	if (typeof value !== "string" || !value) return {};
+	try {
+		const parsed = JSON.parse(value);
+		return isPlainObj(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+async function findRecordById(ctx, convexTable, id) {
+	return await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
+}
+function requireRecord(doc, id) {
+	if (!doc) throw new Error(`Observational memory record not found: ${id}`);
+	return doc;
+}
+const EMPTY_SWAP_RESULT = {
+	chunksActivated: 0,
+	messageTokensActivated: 0,
+	observationTokensActivated: 0,
+	messagesActivated: 0,
+	activatedCycleIds: [],
+	activatedMessageIds: []
+};
+async function handleObservationalMemoryOperation(ctx, convexTable, request) {
+	switch (request.op) {
+		case "omGetLatest": return {
+			ok: true,
+			result: await ctx.db.query(convexTable).withIndex("by_lookup_key", (q) => q.eq("lookupKey", request.lookupKey)).order("desc").first() ?? null
+		};
+		case "omGetHistory": {
+			let docs = await ctx.db.query(convexTable).withIndex("by_lookup_key", (q) => q.eq("lookupKey", request.lookupKey)).order("desc").take(OM_QUERY_MAX_DOCS);
+			if (request.from) docs = docs.filter((doc) => typeof doc.createdAt === "string" && doc.createdAt >= request.from);
+			if (request.to) docs = docs.filter((doc) => typeof doc.createdAt === "string" && doc.createdAt <= request.to);
+			if (request.offset != null) docs = docs.slice(request.offset);
+			return {
+				ok: true,
+				result: docs.slice(0, request.limit)
+			};
+		}
+		case "omUpdateActive": {
+			const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+			const safeTokenCount = Number.isFinite(request.tokenCount) && request.tokenCount >= 0 ? request.tokenCount : 0;
+			await ctx.db.patch(doc._id, {
+				activeObservations: request.observations,
+				lastObservedAt: request.lastObservedAt,
+				pendingMessageTokens: 0,
+				observationTokenCount: safeTokenCount,
+				totalTokensObserved: Number(doc.totalTokensObserved || 0) + safeTokenCount,
+				observedMessageIds: request.observedMessageIds,
+				updatedAt: request.updatedAt
+			});
+			return { ok: true };
+		}
+		case "omAppendBufferedChunk": {
+			const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+			const chunks = parseStoredChunks(doc.bufferedObservationChunks);
+			chunks.push(request.chunk);
+			const patch = {
+				bufferedObservationChunks: JSON.stringify(chunks),
+				updatedAt: request.updatedAt
+			};
+			if (request.lastBufferedAtTime) patch.lastBufferedAtTime = request.lastBufferedAtTime;
+			await ctx.db.patch(doc._id, patch);
+			return { ok: true };
+		}
+		case "omSwapBuffered": {
+			const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+			const persistedChunks = parseStoredChunks(doc.bufferedObservationChunks);
+			if (persistedChunks.length === 0) return {
+				ok: true,
+				result: EMPTY_SWAP_RESULT
+			};
+			const chunks = Array.isArray(request.bufferedChunks) ? request.bufferedChunks : persistedChunks;
+			if (chunks.length === 0) return {
+				ok: true,
+				result: EMPTY_SWAP_RESULT
+			};
+			const chunksToActivate = selectActivationBoundary(chunks, {
+				activationRatio: request.activationRatio,
+				messageTokensThreshold: request.messageTokensThreshold,
+				currentPendingTokens: request.currentPendingTokens,
+				forceMaxActivation: request.forceMaxActivation
+			});
+			const activatedChunks = chunks.slice(0, chunksToActivate);
+			const remainingChunks = chunks.slice(chunksToActivate);
+			const activatedContent = activatedChunks.map((c) => c.observations).join("\n\n");
+			const activatedTokens = activatedChunks.reduce((sum, c) => sum + c.tokenCount, 0);
+			const activatedMessageTokens = activatedChunks.reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
+			const activatedMessageCount = activatedChunks.reduce((sum, c) => sum + (c.messageIds?.length ?? 0), 0);
+			const activatedCycleIds = activatedChunks.map((c) => c.cycleId).filter((id) => !!id);
+			const activatedMessageIds = activatedChunks.flatMap((c) => c.messageIds ?? []);
+			const latestChunk = activatedChunks[activatedChunks.length - 1];
+			const lastObservedAt = request.lastObservedAt ?? latestChunk?.lastObservedAt ?? request.now;
+			const existingActive = doc.activeObservations || "";
+			const boundary = `\n\n--- message boundary (${lastObservedAt}) ---\n\n`;
+			const newActive = existingActive ? `${existingActive}${boundary}${activatedContent}` : activatedContent;
+			await ctx.db.patch(doc._id, {
+				activeObservations: newActive,
+				observationTokenCount: Number(doc.observationTokenCount || 0) + activatedTokens,
+				pendingMessageTokens: Math.max(0, Number(doc.pendingMessageTokens || 0) - activatedMessageTokens),
+				bufferedObservationChunks: remainingChunks.length > 0 ? JSON.stringify(remainingChunks) : null,
+				lastObservedAt,
+				updatedAt: request.now
+			});
+			const latestChunkHints = activatedChunks[activatedChunks.length - 1];
+			return {
+				ok: true,
+				result: {
+					chunksActivated: activatedChunks.length,
+					messageTokensActivated: activatedMessageTokens,
+					observationTokensActivated: activatedTokens,
+					messagesActivated: activatedMessageCount,
+					activatedCycleIds,
+					activatedMessageIds,
+					observations: activatedContent,
+					perChunk: activatedChunks.map((c) => ({
+						cycleId: c.cycleId ?? "",
+						messageTokens: c.messageTokens ?? 0,
+						observationTokens: c.tokenCount,
+						messageCount: c.messageIds?.length ?? 0,
+						observations: c.observations
+					})),
+					suggestedContinuation: latestChunkHints?.suggestedContinuation ?? void 0,
+					currentTask: latestChunkHints?.currentTask ?? void 0
+				}
+			};
+		}
+		case "omUpdateBufferedReflection": {
+			const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+			const existingContent = doc.bufferedReflection || "";
+			await ctx.db.patch(doc._id, {
+				bufferedReflection: existingContent ? `${existingContent}\n\n${request.reflection}` : request.reflection,
+				bufferedReflectionTokens: Number(doc.bufferedReflectionTokens || 0) + request.tokenCount,
+				bufferedReflectionInputTokens: Number(doc.bufferedReflectionInputTokens || 0) + request.inputTokenCount,
+				reflectedObservationLineCount: request.reflectedObservationLineCount,
+				updatedAt: request.updatedAt
+			});
+			return { ok: true };
+		}
+		case "omSwapBufferedReflection": {
+			const { currentRecord, newId, tokenCount, now } = request;
+			const doc = requireRecord(await findRecordById(ctx, convexTable, currentRecord.id), currentRecord.id);
+			const bufferedReflection = doc.bufferedReflection || "";
+			if (!bufferedReflection) throw new Error("No buffered reflection to swap");
+			const newObservations = mergeReflectionWithUnreflected(doc.activeObservations || "", bufferedReflection, Number(doc.reflectedObservationLineCount || 0));
+			const newRecord = {
+				id: newId,
+				lookupKey: currentRecord.lookupKey,
+				scope: currentRecord.scope,
+				resourceId: currentRecord.resourceId,
+				threadId: currentRecord.threadId,
+				activeObservations: newObservations,
+				activeObservationsPendingUpdate: null,
+				originType: "reflection",
+				config: currentRecord.config,
+				generationCount: currentRecord.generationCount + 1,
+				lastObservedAt: currentRecord.lastObservedAt,
+				lastReflectionAt: now,
+				pendingMessageTokens: 0,
+				totalTokensObserved: currentRecord.totalTokensObserved,
+				observationTokenCount: tokenCount,
+				isObserving: false,
+				isReflecting: false,
+				isBufferingObservation: false,
+				isBufferingReflection: false,
+				lastBufferedAtTokens: 0,
+				lastBufferedAtTime: null,
+				observedTimezone: currentRecord.observedTimezone,
+				metadata: currentRecord.metadata,
+				createdAt: now,
+				updatedAt: now
+			};
+			await ctx.db.insert(convexTable, newRecord);
+			await ctx.db.patch(doc._id, {
+				bufferedReflection: null,
+				bufferedReflectionTokens: null,
+				bufferedReflectionInputTokens: null,
+				reflectedObservationLineCount: null,
+				updatedAt: now
+			});
+			return {
+				ok: true,
+				result: newRecord
+			};
+		}
+		case "omUpdateConfig": {
+			const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+			const merged = deepMergeOMConfig(parseJsonObject(doc.config), parseJsonObject(request.config));
+			await ctx.db.patch(doc._id, {
+				config: JSON.stringify(merged),
+				updatedAt: request.updatedAt
+			});
+			return { ok: true };
+		}
+	}
+}
+//#endregion
+//#region src/server/workflow-snapshot.ts
+const PENDING_MARKER_KEY = "__mastra_pending__";
+function isPendingMarker(val) {
+	return val !== null && typeof val === "object" && Object.prototype.hasOwnProperty.call(val, PENDING_MARKER_KEY) && val[PENDING_MARKER_KEY] === true && Object.keys(val).length === 1;
+}
+function isSuspendedStepResult(val) {
+	const result = val;
+	return val !== null && typeof val === "object" && "status" in val && result?.status === "suspended" && ("suspendPayload" in val || "suspendedAt" in val);
+}
+function canResetWithPendingMarker(val) {
+	if (val == null || isPendingMarker(val)) return true;
+	return isSuspendedStepResult(val);
+}
+function createEmptyWorkflowSnapshot(runId) {
+	return {
+		context: {},
+		activePaths: [],
+		activeStepsPath: {},
+		timestamp: Date.now(),
+		suspendedPaths: {},
+		resumeLabels: {},
+		serializedStepGraph: [],
+		value: {},
+		waitingPaths: {},
+		status: "pending",
+		runId
+	};
+}
+function mergeWorkflowStepResult({ snapshot, stepId, result, requestContext }) {
+	if (!snapshot?.context) throw new Error(`Snapshot context not found for runId ${snapshot?.runId}`);
+	const existingResult = snapshot.context[stepId];
+	if (existingResult && "output" in existingResult && Array.isArray(existingResult.output) && result && typeof result === "object" && "output" in result && Array.isArray(result.output)) {
+		const existingOutput = existingResult.output;
+		const newOutput = result.output;
+		const mergedOutput = [...existingOutput];
+		const hasPendingMarker = newOutput.some(isPendingMarker);
+		for (let i = 0; i < Math.max(existingOutput.length, newOutput.length); i++) if (i < newOutput.length) {
+			const newVal = newOutput[i];
+			if (isPendingMarker(newVal)) {
+				if (i >= existingOutput.length || canResetWithPendingMarker(existingOutput[i])) mergedOutput[i] = null;
+			} else if (newVal !== null && newVal !== void 0 && !hasPendingMarker) mergedOutput[i] = newVal;
+			else if (i >= existingOutput.length) mergedOutput[i] = null;
+		}
+		snapshot.context[stepId] = {
+			...existingResult,
+			...hasPendingMarker ? {} : result,
+			output: mergedOutput
+		};
+	} else snapshot.context[stepId] = result;
+	snapshot.requestContext = {
+		...snapshot.requestContext,
+		...requestContext
+	};
+	return JSON.parse(JSON.stringify(snapshot.context));
+}
+//#endregion
+//#region src/server/storage.ts
+const TABLE_VECTOR_INDEXES = "mastra_vector_indexes";
+const VECTOR_TABLE_PREFIX = "mastra_vector_";
+const CONVEX_TABLE_WORKFLOW_SNAPSHOTS = "mastra_workflow_snapshots";
+const CONVEX_TABLE_BACKGROUND_TASKS = "mastra_background_tasks";
+const CONVEX_TABLE_DOCUMENTS = "mastra_documents";
+const CONVEX_TABLE_OBSERVATIONAL_MEMORY = "mastra_observational_memory";
+const STORAGE_MUTATION_BATCH_SIZE = 25;
+const LOAD_MANY_MAX_IDS_PER_REQUEST = 10;
+const DEFAULT_SCHEDULE_QUERY_LIMIT = 100;
+const BACKGROUND_TASK_FIELD_ALIASES = {
+	tool_call_id: "toolCallId",
+	toolCallId: "tool_call_id",
+	tool_name: "toolName",
+	toolName: "tool_name",
+	agent_id: "agentId",
+	agentId: "agent_id",
+	run_id: "runId",
+	runId: "run_id",
+	thread_id: "threadId",
+	threadId: "thread_id",
+	resource_id: "resourceId",
+	resourceId: "resource_id",
+	suspend_payload: "suspendPayload",
+	suspendPayload: "suspend_payload",
+	retry_count: "retryCount",
+	retryCount: "retry_count",
+	max_retries: "maxRetries",
+	maxRetries: "max_retries",
+	timeout_ms: "timeoutMs",
+	timeoutMs: "timeout_ms"
+};
+function normalizeScheduleQueryLimit(limit) {
+	if (limit == null || !Number.isFinite(limit)) return DEFAULT_SCHEDULE_QUERY_LIMIT;
+	return Math.max(0, Math.floor(limit));
+}
+function normalizeLoadManyIds(ids) {
+	if (ids.length > LOAD_MANY_MAX_IDS_PER_REQUEST) throw new Error(`loadMany supports at most ${LOAD_MANY_MAX_IDS_PER_REQUEST} ids per request`);
+	return [...new Set(ids)];
+}
+function applyConvexEqualityFilters(query, filters, indexedFields = /* @__PURE__ */ new Set()) {
+	const remainingFilters = filters?.filter((filter) => !indexedFields.has(filter.field));
+	if (!remainingFilters?.length) return query;
+	return query.filter((q) => {
+		const predicates = remainingFilters.map((filter) => q.eq(q.field(filter.field), filter.value));
+		return predicates.length === 1 ? predicates[0] : q.and(...predicates);
+	});
+}
+async function mapInBatches$1(inputs, batchSize, mapper) {
+	const results = [];
+	for (let index = 0; index < inputs.length; index += batchSize) results.push(...await Promise.all(inputs.slice(index, index + batchSize).map(mapper)));
+	return results;
+}
+async function deleteDocs(ctx, docs) {
+	await mapInBatches$1(docs, STORAGE_MUTATION_BATCH_SIZE, (doc) => ctx.db.delete(doc._id));
+}
+async function findExistingDocsByIds(ids, findDoc) {
+	return (await mapInBatches$1([...new Set(ids)], STORAGE_MUTATION_BATCH_SIZE, findDoc)).filter((doc) => Boolean(doc));
+}
+function isBackgroundTasksTable(convexTable, request) {
+	return convexTable === CONVEX_TABLE_BACKGROUND_TASKS && request.tableName === _mastra_core_storage_constants.TABLE_BACKGROUND_TASKS;
+}
+function matchesFilters(record, filters) {
+	return filters.every((filter) => {
+		if (record[filter.field] === filter.value) return true;
+		const alternateField = BACKGROUND_TASK_FIELD_ALIASES[filter.field];
+		return alternateField ? record[alternateField] === filter.value : false;
+	});
+}
+function mergeLegacyRecord(record, patch) {
+	const merged = { ...record };
+	for (const [field, value] of Object.entries(patch)) {
+		const alternateField = BACKGROUND_TASK_FIELD_ALIASES[field];
+		if (alternateField) delete merged[alternateField];
+		merged[field] = value;
+	}
+	return merged;
+}
+function stripPatchKeys(record, keys) {
+	const stripped = { ...record };
+	for (const key of keys) delete stripped[key];
+	return stripped;
+}
+function dedupeByRecordId(records) {
+	const seen = /* @__PURE__ */ new Set();
+	return records.filter((record) => {
+		if (record?.id == null) return true;
+		const id = String(record.id);
+		if (seen.has(id)) return false;
+		seen.add(id);
+		return true;
+	});
+}
+function isMissingBackgroundTaskSchemaError(error) {
+	const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+	return message.includes(CONVEX_TABLE_BACKGROUND_TASKS) && (message.includes("does not exist") || message.includes("not found") || message.includes("not defined") || message.includes("no such"));
+}
+async function findGenericDocumentById(ctx, tableName, id) {
+	return await ctx.db.query(CONVEX_TABLE_DOCUMENTS).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", String(id))).unique();
+}
+async function findGenericDocumentsByTable(ctx, tableName, limit) {
+	return await ctx.db.query(CONVEX_TABLE_DOCUMENTS).withIndex("by_table", (q) => q.eq("table", tableName)).take(limit);
+}
+async function filterLegacyRecordsWithoutTypedCopy(ctx, convexTable, legacyRecords) {
+	return (await mapInBatches$1(legacyRecords, STORAGE_MUTATION_BATCH_SIZE, async (record) => {
+		if (record.id == null) return record;
+		return await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", String(record.id))).unique() ? null : record;
+	})).filter((record) => Boolean(record));
+}
+function coalesceTypedRecordsForBatchInsert(records) {
+	const recordsById = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		const id = record.id;
+		if (!id) continue;
+		const key = String(id);
+		recordsById.set(key, {
+			...recordsById.get(key) ?? {},
+			...record
+		});
+	}
+	return [...recordsById.values()];
+}
+function coalesceLastRecordById(records) {
+	const recordsById = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		const id = record.id;
+		if (!id) continue;
+		recordsById.set(String(id), record);
+	}
+	return [...recordsById.values()];
+}
+/**
+* Determines which Convex table to use based on the logical table name.
+* Returns the Convex table name and whether it's a typed table or fallback.
+*/
+function resolveTable(tableName) {
+	switch (tableName) {
+		case _mastra_core_storage_constants.TABLE_THREADS: return {
+			convexTable: "mastra_threads",
+			isTyped: true
+		};
+		case _mastra_core_storage_constants.TABLE_MESSAGES: return {
+			convexTable: "mastra_messages",
+			isTyped: true
+		};
+		case _mastra_core_storage_constants.TABLE_RESOURCES: return {
+			convexTable: "mastra_resources",
+			isTyped: true
+		};
+		case _mastra_core_storage_constants.TABLE_WORKFLOW_SNAPSHOT: return {
+			convexTable: CONVEX_TABLE_WORKFLOW_SNAPSHOTS,
+			isTyped: true
+		};
+		case _mastra_core_storage_constants.TABLE_SCORERS: return {
+			convexTable: "mastra_scorers",
+			isTyped: true
+		};
+		case _mastra_core_storage_constants.TABLE_SCHEDULES: return {
+			convexTable: "mastra_schedules",
+			isTyped: true
+		};
+		case _mastra_core_storage_constants.TABLE_SCHEDULE_TRIGGERS: return {
+			convexTable: "mastra_schedule_triggers",
+			isTyped: true
+		};
+		case _mastra_core_storage_constants.TABLE_CHANNEL_INSTALLATIONS: return {
+			convexTable: "mastra_channel_installations",
+			isTyped: true
+		};
+		case _mastra_core_storage_constants.TABLE_CHANNEL_CONFIG: return {
+			convexTable: "mastra_channel_config",
+			isTyped: true
+		};
+		case _mastra_core_storage_constants.TABLE_BACKGROUND_TASKS: return {
+			convexTable: CONVEX_TABLE_BACKGROUND_TASKS,
+			isTyped: true
+		};
+		case TABLE_VECTOR_INDEXES: return {
+			convexTable: "mastra_vector_indexes",
+			isTyped: true
+		};
+		case CONVEX_TABLE_OBSERVATIONAL_MEMORY: return {
+			convexTable: CONVEX_TABLE_OBSERVATIONAL_MEMORY,
+			isTyped: true
+		};
+		default:
+			if (tableName.startsWith(VECTOR_TABLE_PREFIX)) return {
+				convexTable: "mastra_vectors",
+				isTyped: true
+			};
+			return {
+				convexTable: "mastra_documents",
+				isTyped: false
+			};
+	}
+}
+/**
+* Main storage mutation handler.
+* Routes operations to the appropriate typed table.
+*/
+const mastraStorage = (0, convex_server.mutationGeneric)(async (ctx, request) => {
+	try {
+		const { convexTable, isTyped } = resolveTable(request.tableName);
+		if (request.tableName.startsWith(VECTOR_TABLE_PREFIX) && request.tableName !== TABLE_VECTOR_INDEXES) return await handleVectorOperation(ctx, request);
+		if (isTyped) {
+			if (isBackgroundTasksTable(convexTable, request)) try {
+				return await handleTypedOperation(ctx, convexTable, request);
+			} catch (error) {
+				if (!isMissingBackgroundTaskSchemaError(error)) throw error;
+				return handleGenericOperation(ctx, request);
+			}
+			return handleTypedOperation(ctx, convexTable, request);
+		}
+		return handleGenericOperation(ctx, request);
+	} catch (error) {
+		return {
+			ok: false,
+			error: error.message
+		};
+	}
+});
+function parseStoredSnapshot(stored, runId) {
+	if (typeof stored === "string") return JSON.parse(stored);
+	return JSON.parse(JSON.stringify(stored ?? createEmptyWorkflowSnapshot(runId)));
+}
+function parseMetadataForMerge(metadata) {
+	if (metadata == null) return {};
+	if (typeof metadata === "string") try {
+		return parseMetadataForMerge(JSON.parse(metadata));
+	} catch {
+		return {};
+	}
+	if (typeof metadata === "object" && !Array.isArray(metadata)) return metadata;
+	return {};
+}
+function mergeMetadata(existing, update) {
+	return {
+		...parseMetadataForMerge(existing),
+		...update ?? {}
+	};
+}
+/**
+* Handle operations on typed tables (threads, messages, etc.)
+* Records are stored with their `id` field as a regular field (not _id).
+* We query by the `id` field to find/update records.
+*/
+async function handleTypedOperation(ctx, convexTable, request) {
+	switch (request.op) {
+		case "omGetLatest":
+		case "omGetHistory":
+		case "omUpdateActive":
+		case "omAppendBufferedChunk":
+		case "omSwapBuffered":
+		case "omUpdateBufferedReflection":
+		case "omSwapBufferedReflection":
+		case "omUpdateConfig":
+			if (convexTable !== CONVEX_TABLE_OBSERVATIONAL_MEMORY) throw new Error(`${request.op} is only supported for ${CONVEX_TABLE_OBSERVATIONAL_MEMORY}`);
+			return handleObservationalMemoryOperation(ctx, convexTable, request);
+		case "createSchedule": {
+			if (convexTable !== "mastra_schedules") throw new Error(`createSchedule is only supported for mastra_schedules`);
+			const record = request.record;
+			const id = record.id;
+			if (!id) throw new Error(`Schedule is missing an id`);
+			if (await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique()) throw new Error(`Schedule with id "${id}" already exists`);
+			await ctx.db.insert(convexTable, record);
+			return { ok: true };
+		}
+		case "recordScheduleTrigger": {
+			if (convexTable !== "mastra_schedule_triggers") throw new Error(`recordScheduleTrigger is only supported for mastra_schedule_triggers`);
+			const record = request.record;
+			const id = record.id;
+			if (!id) throw new Error(`Schedule trigger is missing an id`);
+			if (await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique()) throw new Error(`Schedule trigger with id "${id}" already exists`);
+			await ctx.db.insert(convexTable, record);
+			return { ok: true };
+		}
+		case "listDueSchedules":
+			if (convexTable !== "mastra_schedules") throw new Error(`listDueSchedules is only supported for mastra_schedules`);
+			return {
+				ok: true,
+				result: await ctx.db.query(convexTable).withIndex("by_status_next_fire_at", (q) => q.eq("status", "active").lte("next_fire_at", request.now)).take(normalizeScheduleQueryLimit(request.limit))
+			};
+		case "updateScheduleNextFire": {
+			if (convexTable !== "mastra_schedules") throw new Error(`updateScheduleNextFire is only supported for mastra_schedules`);
+			const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.id)).unique();
+			if (!existing || existing.status !== "active" || existing.next_fire_at !== request.expectedNextFireAt) return {
+				ok: true,
+				result: false
+			};
+			await ctx.db.patch(existing._id, {
+				next_fire_at: request.newNextFireAt,
+				last_fire_at: request.lastFireAt,
+				last_run_id: request.lastRunId,
+				updated_at: Date.now()
+			});
+			return {
+				ok: true,
+				result: true
+			};
+		}
+		case "updateSchedule": {
+			if (convexTable !== "mastra_schedules") throw new Error(`updateSchedule is only supported for mastra_schedules`);
+			const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.id)).unique();
+			if (!existing) throw new Error(`Schedule ${request.id} not found`);
+			await ctx.db.patch(existing._id, request.patch);
+			return {
+				ok: true,
+				result: {
+					...existing,
+					...request.patch
+				}
+			};
+		}
+		case "listScheduleTriggers":
+			if (convexTable !== "mastra_schedule_triggers") throw new Error(`listScheduleTriggers is only supported for mastra_schedule_triggers`);
+			return {
+				ok: true,
+				result: await ctx.db.query(convexTable).withIndex("by_schedule_actual", (q) => {
+					let builder = q.eq("schedule_id", request.scheduleId);
+					if (request.fromActualFireAt != null) builder = builder.gte("actual_fire_at", request.fromActualFireAt);
+					if (request.toActualFireAt != null) builder = builder.lt("actual_fire_at", request.toActualFireAt);
+					return builder;
+				}).order("desc").take(normalizeScheduleQueryLimit(request.limit))
+			};
+		case "deleteScheduleTriggers": {
+			if (convexTable !== "mastra_schedule_triggers") throw new Error(`deleteScheduleTriggers is only supported for mastra_schedule_triggers`);
+			const docs = await ctx.db.query(convexTable).withIndex("by_schedule_actual", (q) => q.eq("schedule_id", request.scheduleId)).take(26);
+			const hasMore = docs.length > STORAGE_MUTATION_BATCH_SIZE;
+			await deleteDocs(ctx, hasMore ? docs.slice(0, STORAGE_MUTATION_BATCH_SIZE) : docs);
+			return {
+				ok: true,
+				hasMore
+			};
+		}
+		case "insert": {
+			const record = request.record;
+			const id = record.id;
+			if (!id) throw new Error(`Record is missing an id`);
+			const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
+			if (existing) {
+				const { id: _, ...updateData } = record;
+				await ctx.db.patch(existing._id, updateData);
+			} else await ctx.db.insert(convexTable, record);
+			return { ok: true };
+		}
+		case "batchInsert":
+			await mapInBatches$1(coalesceTypedRecordsForBatchInsert(request.records), STORAGE_MUTATION_BATCH_SIZE, async (record) => {
+				const id = record.id;
+				const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
+				if (existing) {
+					const { id: _, ...updateData } = record;
+					await ctx.db.patch(existing._id, updateData);
+				} else await ctx.db.insert(convexTable, record);
+			});
+			return { ok: true };
+		case "updateThread": {
+			if (convexTable !== "mastra_threads") return {
+				ok: false,
+				error: `Unsupported operation ${request.op} for table ${request.tableName}`
+			};
+			const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.id)).unique();
+			if (!existing) return {
+				ok: true,
+				result: null
+			};
+			const patchRecord = {
+				title: request.title,
+				metadata: mergeMetadata(existing.metadata, request.metadata),
+				updatedAt: request.updatedAt
+			};
+			await ctx.db.patch(existing._id, patchRecord);
+			return {
+				ok: true,
+				result: {
+					...existing,
+					...patchRecord
+				}
+			};
+		}
+		case "updateResource": {
+			if (convexTable !== "mastra_resources") return {
+				ok: false,
+				error: `Unsupported operation ${request.op} for table ${request.tableName}`
+			};
+			const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.resourceId)).unique();
+			if (!existing) {
+				const record = {
+					id: request.resourceId,
+					...request.workingMemory !== void 0 ? { workingMemory: request.workingMemory } : {},
+					metadata: request.metadata ?? {},
+					createdAt: request.createdAt,
+					updatedAt: request.updatedAt
+				};
+				await ctx.db.insert(convexTable, record);
+				return {
+					ok: true,
+					result: record
+				};
+			}
+			const patchRecord = { updatedAt: request.updatedAt };
+			if (request.workingMemory !== void 0) patchRecord.workingMemory = request.workingMemory;
+			if (request.metadata !== void 0) patchRecord.metadata = mergeMetadata(existing.metadata, request.metadata);
+			await ctx.db.patch(existing._id, patchRecord);
+			return {
+				ok: true,
+				result: {
+					...existing,
+					...patchRecord
+				}
+			};
+		}
+		case "patch": {
+			const patchRecord = stripPatchKeys(request.record, ["id"]);
+			const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.id)).unique();
+			if (!existing) {
+				if (isBackgroundTasksTable(convexTable, request)) {
+					const legacy = await findGenericDocumentById(ctx, request.tableName, request.id);
+					if (legacy) {
+						await ctx.db.patch(legacy._id, { record: mergeLegacyRecord(legacy.record, patchRecord) });
+						return {
+							ok: true,
+							result: true
+						};
+					}
+				}
+				return {
+					ok: true,
+					result: false
+				};
+			}
+			await ctx.db.patch(existing._id, patchRecord);
+			if (isBackgroundTasksTable(convexTable, request)) {
+				const legacy = await findGenericDocumentById(ctx, request.tableName, request.id);
+				if (legacy) await ctx.db.delete(legacy._id);
+			}
+			return {
+				ok: true,
+				result: true
+			};
+		}
+		case "load": {
+			const keys = request.keys;
+			if (keys.id) {
+				const doc = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", keys.id)).unique();
+				if (!doc && isBackgroundTasksTable(convexTable, request)) return {
+					ok: true,
+					result: (await findGenericDocumentById(ctx, request.tableName, String(keys.id)))?.record ?? null
+				};
+				return {
+					ok: true,
+					result: doc || null
+				};
+			}
+			if (convexTable === CONVEX_TABLE_WORKFLOW_SNAPSHOTS && typeof keys.workflow_name === "string" && typeof keys.run_id === "string") return {
+				ok: true,
+				result: await ctx.db.query(convexTable).withIndex("by_workflow_run", (q) => q.eq("workflow_name", keys.workflow_name).eq("run_id", keys.run_id)).unique() || null
+			};
+			return {
+				ok: true,
+				result: (await ctx.db.query(convexTable).take(1e4)).find((doc) => Object.entries(keys).every(([key, value]) => doc[key] === value)) || null
+			};
+		}
+		case "loadMany": {
+			const ids = normalizeLoadManyIds(request.ids);
+			const typedDocs = (await mapInBatches$1(ids, STORAGE_MUTATION_BATCH_SIZE, (id) => ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique())).filter(Boolean);
+			if (!isBackgroundTasksTable(convexTable, request)) return {
+				ok: true,
+				result: typedDocs
+			};
+			const typedDocsById = new Map(typedDocs.map((doc) => [String(doc.id), doc]));
+			const legacyDocs = await mapInBatches$1(ids.filter((id) => !typedDocsById.has(id)), STORAGE_MUTATION_BATCH_SIZE, (id) => findGenericDocumentById(ctx, request.tableName, id));
+			const legacyRecordsById = new Map(legacyDocs.filter((doc) => Boolean(doc)).map((doc) => [String(doc.record.id), doc.record]));
+			return {
+				ok: true,
+				result: ids.map((id) => typedDocsById.get(id) ?? legacyRecordsById.get(id)).filter(Boolean)
+			};
+		}
+		case "queryTable": {
+			const maxDocs = request.limit ? Math.min(request.limit * 2, 1e4) : 1e4;
+			let query;
+			let indexedFields = /* @__PURE__ */ new Set();
+			if (request.indexHint) {
+				const hint = request.indexHint;
+				if (hint.index === "by_workflow") query = ctx.db.query(convexTable).withIndex("by_workflow", (q) => q.eq("workflow_name", hint.workflowName));
+				else if (hint.index === "by_workflow_run") query = ctx.db.query(convexTable).withIndex("by_workflow_run", (q) => q.eq("workflow_name", hint.workflowName).eq("run_id", hint.runId));
+				else query = ctx.db.query(convexTable);
+			} else if (request.filters && request.filters.length > 0) {
+				const match = findBestIndex(convexTable, request.filters);
+				if (match) {
+					query = ctx.db.query(convexTable).withIndex(match.indexName, (q) => {
+						let builder = q;
+						for (const filter of match.indexedFilters) builder = builder.eq(filter.field, filter.value);
+						return builder;
+					});
+					indexedFields = new Set(match.indexedFilters.map((filter) => filter.field));
+				} else query = ctx.db.query(convexTable);
+			} else query = ctx.db.query(convexTable);
+			let docs = await applyConvexEqualityFilters(query, request.filters, indexedFields).take(maxDocs);
+			if (isBackgroundTasksTable(convexTable, request)) {
+				let legacyRecords = (await findGenericDocumentsByTable(ctx, request.tableName, maxDocs)).map((doc) => doc.record);
+				if (request.filters && request.filters.length > 0) legacyRecords = legacyRecords.filter((record) => matchesFilters(record, request.filters));
+				legacyRecords = await filterLegacyRecordsWithoutTypedCopy(ctx, convexTable, legacyRecords);
+				docs.push(...legacyRecords);
+				docs = dedupeByRecordId(docs);
+			}
+			if (request.limit) docs = docs.slice(0, request.limit);
+			return {
+				ok: true,
+				result: docs
+			};
+		}
+		case "clearTable":
+		case "dropTable": {
+			const docs = await ctx.db.query(convexTable).take(26);
+			const hasMore = docs.length > STORAGE_MUTATION_BATCH_SIZE;
+			let docsToDelete = hasMore ? docs.slice(0, STORAGE_MUTATION_BATCH_SIZE) : docs;
+			let legacyHasMore = false;
+			if (!hasMore && docsToDelete.length < STORAGE_MUTATION_BATCH_SIZE && isBackgroundTasksTable(convexTable, request)) {
+				const remainingBatchSize = STORAGE_MUTATION_BATCH_SIZE - docsToDelete.length;
+				const legacyDocs = await findGenericDocumentsByTable(ctx, request.tableName, remainingBatchSize + 1);
+				legacyHasMore = legacyDocs.length > remainingBatchSize;
+				docsToDelete = docsToDelete.concat(legacyHasMore ? legacyDocs.slice(0, remainingBatchSize) : legacyDocs);
+			}
+			await deleteDocs(ctx, docsToDelete);
+			return {
+				ok: true,
+				hasMore: hasMore || legacyHasMore
+			};
+		}
+		case "deleteMany": {
+			const docsToDelete = await findExistingDocsByIds(request.ids, (id) => ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique());
+			if (isBackgroundTasksTable(convexTable, request)) docsToDelete.push(...await findExistingDocsByIds(request.ids, (id) => findGenericDocumentById(ctx, request.tableName, id)));
+			await deleteDocs(ctx, docsToDelete);
+			return { ok: true };
+		}
+		case "mergeWorkflowStepResult": {
+			if (convexTable !== CONVEX_TABLE_WORKFLOW_SNAPSHOTS) return {
+				ok: false,
+				error: `Unsupported operation ${request.op} for table ${request.tableName}`
+			};
+			const existing = await ctx.db.query(convexTable).withIndex("by_workflow_run", (q) => q.eq("workflow_name", request.workflowName).eq("run_id", request.runId)).unique();
+			if (!existing) return {
+				ok: false,
+				error: `Workflow snapshot not found for runId ${request.runId}`
+			};
+			const snapshot = parseStoredSnapshot(existing.snapshot, request.runId);
+			if (!snapshot.context) return {
+				ok: false,
+				error: `Snapshot for runId ${request.runId} is missing or has invalid context`
+			};
+			const context = mergeWorkflowStepResult({
+				snapshot,
+				stepId: request.stepId,
+				result: JSON.parse(request.result),
+				requestContext: JSON.parse(request.requestContext)
+			});
+			await ctx.db.patch(existing._id, {
+				snapshot: JSON.stringify(snapshot),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			return {
+				ok: true,
+				result: JSON.stringify(context)
+			};
+		}
+		case "mergeWorkflowState": {
+			if (convexTable !== CONVEX_TABLE_WORKFLOW_SNAPSHOTS) return {
+				ok: false,
+				error: `Unsupported operation ${request.op} for table ${request.tableName}`
+			};
+			const existing = await ctx.db.query(convexTable).withIndex("by_workflow_run", (q) => q.eq("workflow_name", request.workflowName).eq("run_id", request.runId)).unique();
+			if (!existing) return {
+				ok: false,
+				error: `Workflow snapshot not found for runId ${request.runId}`
+			};
+			const snapshot = parseStoredSnapshot(existing.snapshot, request.runId);
+			if (!snapshot.context) return {
+				ok: false,
+				error: `Snapshot for runId ${request.runId} is missing or has invalid context`
+			};
+			const mergedSnapshot = {
+				...snapshot,
+				...JSON.parse(request.opts)
+			};
+			await ctx.db.patch(existing._id, {
+				snapshot: JSON.stringify(mergedSnapshot),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			return {
+				ok: true,
+				result: JSON.stringify(mergedSnapshot)
+			};
+		}
+		default: return {
+			ok: false,
+			error: `Unsupported operation ${request.op}`
+		};
+	}
+}
+/**
+* Handle operations on the vectors table.
+* Vectors are stored with indexName to support multiple indexes.
+*/
+async function handleVectorOperation(ctx, request) {
+	const indexName = request.tableName.replace(VECTOR_TABLE_PREFIX, "");
+	const convexTable = "mastra_vectors";
+	switch (request.op) {
+		case "insert": {
+			const record = request.record;
+			const id = record.id;
+			if (!id) throw new Error(`Vector record is missing an id`);
+			const existing = await ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", id)).unique();
+			if (existing) await ctx.db.patch(existing._id, {
+				embedding: record.embedding,
+				metadata: record.metadata
+			});
+			else await ctx.db.insert(convexTable, {
+				id,
+				indexName,
+				embedding: record.embedding,
+				metadata: record.metadata
+			});
+			return { ok: true };
+		}
+		case "batchInsert":
+			await mapInBatches$1(coalesceLastRecordById(request.records), STORAGE_MUTATION_BATCH_SIZE, async (record) => {
+				const id = record.id;
+				const existing = await ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", id)).unique();
+				if (existing) await ctx.db.patch(existing._id, {
+					embedding: record.embedding,
+					metadata: record.metadata
+				});
+				else await ctx.db.insert(convexTable, {
+					id,
+					indexName,
+					embedding: record.embedding,
+					metadata: record.metadata
+				});
+			});
+			return { ok: true };
+		case "patch": {
+			const patchRecord = stripPatchKeys(request.record, ["id", "indexName"]);
+			const existing = await ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", request.id)).unique();
+			if (!existing) return {
+				ok: true,
+				result: false
+			};
+			await ctx.db.patch(existing._id, patchRecord);
+			return {
+				ok: true,
+				result: true
+			};
+		}
+		case "load": {
+			const keys = request.keys;
+			if (keys.id) return {
+				ok: true,
+				result: await ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", keys.id)).unique() || null
+			};
+			return {
+				ok: true,
+				result: null
+			};
+		}
+		case "loadMany": return {
+			ok: true,
+			result: await findExistingDocsByIds(normalizeLoadManyIds(request.ids), (id) => ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", id)).unique())
+		};
+		case "queryTable": {
+			if (request.cursor !== void 0 && request.pageSize === void 0) throw new Error("queryTable cursor requires pageSize");
+			if (request.pageSize !== void 0) {
+				if (!Number.isInteger(request.pageSize) || request.pageSize <= 0) throw new Error("queryTable pageSize must be a positive integer");
+				if (request.limit !== void 0) throw new Error("queryTable limit cannot be combined with pageSize");
+				const page = await ctx.db.query(convexTable).withIndex("by_index", (q) => q.eq("indexName", indexName)).paginate({
+					cursor: request.cursor ?? null,
+					numItems: request.pageSize
+				});
+				let docs = page.page;
+				if (request.filters && request.filters.length > 0) docs = docs.filter((doc) => request.filters.every((filter) => doc[filter.field] === filter.value));
+				return {
+					ok: true,
+					result: docs,
+					hasMore: !page.isDone,
+					continuationCursor: page.continueCursor
+				};
+			}
+			const maxDocs = request.limit ? Math.min(request.limit * 2, 1e4) : 1e4;
+			let docs = await ctx.db.query(convexTable).withIndex("by_index", (q) => q.eq("indexName", indexName)).take(maxDocs);
+			if (request.filters && request.filters.length > 0) docs = docs.filter((doc) => request.filters.every((filter) => doc[filter.field] === filter.value));
+			if (request.limit) docs = docs.slice(0, request.limit);
+			return {
+				ok: true,
+				result: docs
+			};
+		}
+		case "clearTable":
+		case "dropTable": {
+			const docs = await ctx.db.query(convexTable).withIndex("by_index", (q) => q.eq("indexName", indexName)).take(26);
+			const hasMore = docs.length > STORAGE_MUTATION_BATCH_SIZE;
+			await deleteDocs(ctx, hasMore ? docs.slice(0, STORAGE_MUTATION_BATCH_SIZE) : docs);
+			return {
+				ok: true,
+				hasMore
+			};
+		}
+		case "deleteMany":
+			await deleteDocs(ctx, await findExistingDocsByIds(request.ids, (id) => ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", id)).unique()));
+			return { ok: true };
+		default: return {
+			ok: false,
+			error: `Unsupported operation ${request.op}`
+		};
+	}
+}
+/**
+* Handle operations on the generic documents table.
+* Used as fallback for unknown table names.
+*/
+async function handleGenericOperation(ctx, request) {
+	const tableName = request.tableName;
+	const convexTable = "mastra_documents";
+	switch (request.op) {
+		case "insert": {
+			const record = request.record;
+			if (!record.id) throw new Error(`Record for table ${tableName} is missing an id`);
+			const primaryKey = String(record.id);
+			const existing = await ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", primaryKey)).unique();
+			if (existing) await ctx.db.patch(existing._id, { record });
+			else await ctx.db.insert(convexTable, {
+				table: tableName,
+				primaryKey,
+				record
+			});
+			return { ok: true };
+		}
+		case "batchInsert":
+			await mapInBatches$1(coalesceLastRecordById(request.records), STORAGE_MUTATION_BATCH_SIZE, async (record) => {
+				const primaryKey = String(record.id);
+				const existing = await ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", primaryKey)).unique();
+				if (existing) await ctx.db.patch(existing._id, { record });
+				else await ctx.db.insert(convexTable, {
+					table: tableName,
+					primaryKey,
+					record
+				});
+			});
+			return { ok: true };
+		case "patch": {
+			const patchRecord = stripPatchKeys(request.record, ["id"]);
+			const existing = await ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", String(request.id))).unique();
+			if (!existing) return {
+				ok: true,
+				result: false
+			};
+			await ctx.db.patch(existing._id, { record: tableName === _mastra_core_storage_constants.TABLE_BACKGROUND_TASKS ? mergeLegacyRecord(existing.record, patchRecord) : {
+				...existing.record,
+				...patchRecord
+			} });
+			return {
+				ok: true,
+				result: true
+			};
+		}
+		case "load": {
+			const keys = request.keys;
+			if (keys.id) {
+				const existing = await ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", String(keys.id))).unique();
+				return {
+					ok: true,
+					result: existing ? existing.record : null
+				};
+			}
+			const match = (await ctx.db.query(convexTable).withIndex("by_table", (q) => q.eq("table", tableName)).take(1e4)).find((doc) => Object.entries(keys).every(([key, value]) => doc.record?.[key] === value));
+			return {
+				ok: true,
+				result: match ? match.record : null
+			};
+		}
+		case "loadMany": return {
+			ok: true,
+			result: (await mapInBatches$1(normalizeLoadManyIds(request.ids), STORAGE_MUTATION_BATCH_SIZE, (id) => findGenericDocumentById(ctx, tableName, id))).filter((doc) => Boolean(doc)).map((doc) => doc.record)
+		};
+		case "queryTable": {
+			const maxDocs = request.limit ? Math.min(request.limit * 2, 1e4) : 1e4;
+			let records = (await ctx.db.query(convexTable).withIndex("by_table", (q) => q.eq("table", tableName)).take(maxDocs)).map((doc) => doc.record);
+			if (request.filters && request.filters.length > 0) records = records.filter((record) => tableName === _mastra_core_storage_constants.TABLE_BACKGROUND_TASKS ? matchesFilters(record, request.filters) : request.filters.every((filter) => record?.[filter.field] === filter.value));
+			if (request.limit) records = records.slice(0, request.limit);
+			return {
+				ok: true,
+				result: records
+			};
+		}
+		case "clearTable":
+		case "dropTable": {
+			const docs = await ctx.db.query(convexTable).withIndex("by_table", (q) => q.eq("table", tableName)).take(26);
+			const hasMore = docs.length > STORAGE_MUTATION_BATCH_SIZE;
+			await deleteDocs(ctx, hasMore ? docs.slice(0, STORAGE_MUTATION_BATCH_SIZE) : docs);
+			return {
+				ok: true,
+				hasMore
+			};
+		}
+		case "deleteMany":
+			await deleteDocs(ctx, await findExistingDocsByIds(request.ids, (id) => ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", String(id))).unique()));
+			return { ok: true };
+		default: return {
+			ok: false,
+			error: `Unsupported operation ${request.op}`
+		};
+	}
+}
+//#endregion
+//#region src/server/native-vector.ts
+const DEFAULT_ID_FIELD = "id";
+const DEFAULT_ID_INDEX = "by_record_id";
+const DEFAULT_VECTOR_FIELD = "embedding";
+const DEFAULT_METADATA_FIELD = "metadata";
+const NATIVE_VECTOR_BATCH_SIZE = 25;
+const MAX_CONVEX_VECTOR_RESULTS = 256;
+const nativeVectorFilterValueValidator = convex_values.v.union(convex_values.v.string(), convex_values.v.number(), convex_values.v.boolean(), convex_values.v.null());
+const nativeVectorFilterClauseValidator = convex_values.v.object({
+	field: convex_values.v.string(),
+	value: nativeVectorFilterValueValidator
+});
+const nativeVectorFilterValidator = convex_values.v.union(nativeVectorFilterClauseValidator, convex_values.v.object({ $or: convex_values.v.array(nativeVectorFilterClauseValidator) }));
+const nativeVectorIndexConfigValidator = convex_values.v.object({
+	tableName: convex_values.v.string(),
+	vectorIndexName: convex_values.v.string(),
+	dimension: convex_values.v.optional(convex_values.v.number()),
+	idField: convex_values.v.optional(convex_values.v.string()),
+	idIndexName: convex_values.v.optional(convex_values.v.string()),
+	vectorField: convex_values.v.optional(convex_values.v.string()),
+	metadataField: convex_values.v.optional(convex_values.v.string()),
+	filterFields: convex_values.v.optional(convex_values.v.array(convex_values.v.string()))
+});
+function idField(config) {
+	return config.idField ?? DEFAULT_ID_FIELD;
+}
+function idIndexName(config) {
+	return config.idIndexName ?? DEFAULT_ID_INDEX;
+}
+function vectorField(config) {
+	return config.vectorField ?? DEFAULT_VECTOR_FIELD;
+}
+function metadataField(config) {
+	return config.metadataField ?? DEFAULT_METADATA_FIELD;
+}
+function asTableName(tableName) {
+	return tableName;
+}
+function asConvexId(id) {
+	return id;
+}
+function pickFilterFields(metadata, filterFields) {
+	const fields = {};
+	if (!metadata || !filterFields) return fields;
+	for (const field of filterFields) {
+		const value = metadata[field];
+		if (value !== void 0) fields[field] = value;
+	}
+	return fields;
+}
+function isMetadataRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateMetadataArray(metadata, idsLength) {
+	if (metadata === void 0) return void 0;
+	if (!Array.isArray(metadata)) throw new Error("Native vector upsert: metadata must be an array matching ids when provided");
+	if (metadata.length !== idsLength) throw new Error(`Native vector upsert: metadata length (${metadata.length}) must match ids length (${idsLength})`);
+	if (!metadata.every(isMetadataRecord)) throw new Error("Native vector upsert: metadata entries must be objects when provided");
+	return metadata;
+}
+function validateMetadataRecord(metadata) {
+	if (metadata === void 0) return void 0;
+	if (!isMetadataRecord(metadata)) throw new Error("Native vector update: metadata must be an object when provided");
+	return metadata;
+}
+function clearMissingFilterFields(patch, metadata, filterFields) {
+	if (!filterFields) return;
+	for (const field of filterFields) if (metadata[field] === void 0) patch[field] = void 0;
+}
+function omitVectorField(doc, config) {
+	const { [vectorField(config)]: _, ...docWithoutVector } = doc;
+	return docWithoutVector;
+}
+function buildRecord({ config, id, vector, metadata }) {
+	return {
+		[idField(config)]: id,
+		[vectorField(config)]: vector,
+		...metadata !== void 0 ? { [metadataField(config)]: metadata } : {},
+		...pickFilterFields(metadata, config.filterFields)
+	};
+}
+async function findByRecordId(ctx, config, id) {
+	return ctx.db.query(asTableName(config.tableName)).withIndex(idIndexName(config), (q) => q.eq(idField(config), id)).unique();
+}
+async function mapInBatches(inputs, mapper) {
+	const results = [];
+	for (let index = 0; index < inputs.length; index += NATIVE_VECTOR_BATCH_SIZE) results.push(...await Promise.all(inputs.slice(index, index + NATIVE_VECTOR_BATCH_SIZE).map((input, batchIndex) => mapper(input, index + batchIndex))));
+	return results;
+}
+function buildVectorFilter(q, filter) {
+	if (!filter) return void 0;
+	if ("$or" in filter) return q.or(...filter.$or.map((clause) => q.eq(clause.field, clause.value)));
+	return q.eq(filter.field, filter.value);
+}
+const mastraNativeVectorAction = (0, convex_server.actionGeneric)({
+	args: {
+		config: nativeVectorIndexConfigValidator,
+		vector: convex_values.v.array(convex_values.v.number()),
+		limit: convex_values.v.optional(convex_values.v.number()),
+		filter: convex_values.v.optional(nativeVectorFilterValidator)
+	},
+	handler: async (ctx, args) => {
+		const config = args.config;
+		const limit = args.limit;
+		const filter = args.filter;
+		if (limit !== void 0 && (!Number.isInteger(limit) || limit < 1 || limit > MAX_CONVEX_VECTOR_RESULTS)) throw new Error(`Native vector query: limit must be an integer between 1 and ${MAX_CONVEX_VECTOR_RESULTS}`);
+		return (await ctx.vectorSearch(asTableName(config.tableName), config.vectorIndexName, {
+			vector: args.vector,
+			...limit !== void 0 ? { limit } : {},
+			...filter ? { filter: (q) => buildVectorFilter(q, filter) } : {}
+		})).map((result) => ({
+			id: String(result._id),
+			score: result._score
+		}));
+	}
+});
+const mastraNativeVectorQuery = (0, convex_server.queryGeneric)({
+	args: {
+		op: convex_values.v.union(convex_values.v.literal("getByConvexIds"), convex_values.v.literal("describe"), convex_values.v.literal("listByIds")),
+		config: nativeVectorIndexConfigValidator,
+		ids: convex_values.v.optional(convex_values.v.array(convex_values.v.string())),
+		includeVector: convex_values.v.optional(convex_values.v.boolean()),
+		countLimit: convex_values.v.optional(convex_values.v.number())
+	},
+	handler: async (ctx, args) => {
+		const config = args.config;
+		switch (args.op) {
+			case "getByConvexIds": {
+				const ids = args.ids;
+				if (!ids) throw new Error("Native vector query: ids are required");
+				const includeVector = args.includeVector === true;
+				return (await mapInBatches(ids, (id) => ctx.db.get(asConvexId(id)))).filter((doc) => Boolean(doc)).map((doc) => includeVector ? doc : omitVectorField(doc, config));
+			}
+			case "describe": {
+				const limit = Math.max(1, Math.min(args.countLimit ?? 1e4, 1e4));
+				const docs = await ctx.db.query(asTableName(config.tableName)).take(limit + 1);
+				return {
+					count: Math.min(docs.length, limit),
+					countIsLimited: docs.length > limit
+				};
+			}
+			case "listByIds": {
+				const ids = args.ids;
+				if (!ids) throw new Error("Native vector query: ids are required");
+				return mapInBatches(ids, (id) => findByRecordId(ctx, config, id));
+			}
+			default: throw new Error(`Unsupported native vector query operation: ${args.op}`);
+		}
+	}
+});
+const mastraNativeVectorMutation = (0, convex_server.mutationGeneric)({
+	args: {
+		op: convex_values.v.union(convex_values.v.literal("upsert"), convex_values.v.literal("updateById"), convex_values.v.literal("deleteByIds")),
+		config: nativeVectorIndexConfigValidator,
+		ids: convex_values.v.optional(convex_values.v.array(convex_values.v.string())),
+		vectors: convex_values.v.optional(convex_values.v.array(convex_values.v.array(convex_values.v.number()))),
+		metadata: convex_values.v.optional(convex_values.v.any()),
+		id: convex_values.v.optional(convex_values.v.string()),
+		vector: convex_values.v.optional(convex_values.v.array(convex_values.v.number()))
+	},
+	handler: async (ctx, args) => {
+		const config = args.config;
+		switch (args.op) {
+			case "upsert": {
+				const ids = args.ids;
+				const vectors = args.vectors;
+				if (!ids || !vectors) throw new Error("Native vector upsert: ids and vectors are required");
+				if (vectors.length !== ids.length) throw new Error(`Native vector upsert: vectors length (${vectors.length}) must match ids length (${ids.length})`);
+				const metadata = validateMetadataArray(args.metadata, ids.length);
+				if (new Set(ids).size !== ids.length) throw new Error("Native vector upsert: ids must be unique");
+				await mapInBatches(ids, async (id, index) => {
+					const record = buildRecord({
+						config,
+						id,
+						vector: vectors[index],
+						metadata: metadata?.[index]
+					});
+					const existing = await findByRecordId(ctx, config, id);
+					if (existing?._id) {
+						const { _id: _, _creationTime: __, ...patch } = record;
+						if (metadata?.[index] !== void 0) clearMissingFilterFields(patch, metadata[index], config.filterFields);
+						await ctx.db.patch(existing._id, patch);
+					} else await ctx.db.insert(asTableName(config.tableName), record);
+				});
+				return { ok: true };
+			}
+			case "updateById": {
+				if (!args.id) throw new Error("Native vector update: id is required");
+				const existing = await findByRecordId(ctx, config, args.id);
+				if (!existing?._id) return { ok: true };
+				const patch = {};
+				if (args.vector) patch[vectorField(config)] = args.vector;
+				const metadata = validateMetadataRecord(args.metadata);
+				if (metadata !== void 0) {
+					const existingMetadata = isMetadataRecord(existing[metadataField(config)]) ? existing[metadataField(config)] : {};
+					patch[metadataField(config)] = {
+						...existingMetadata,
+						...metadata
+					};
+					Object.assign(patch, pickFilterFields(patch[metadataField(config)], config.filterFields));
+				}
+				if (Object.keys(patch).length > 0) await ctx.db.patch(existing._id, patch);
+				return { ok: true };
+			}
+			case "deleteByIds": {
+				const ids = args.ids;
+				if (!ids) throw new Error("Native vector deleteByIds: ids are required");
+				await mapInBatches((await mapInBatches(ids, (id) => findByRecordId(ctx, config, id))).filter((doc) => Boolean(doc?._id)), (doc) => ctx.db.delete(doc._id));
+				return { ok: true };
+			}
+			default: throw new Error(`Unsupported native vector mutation operation: ${args.op}`);
+		}
+	}
+});
+//#endregion
+Object.defineProperty(exports, "mastraCache", {
+	enumerable: true,
+	get: function() {
+		return mastraCache;
+	}
+});
+Object.defineProperty(exports, "mastraNativeVectorAction", {
+	enumerable: true,
+	get: function() {
+		return mastraNativeVectorAction;
+	}
+});
+Object.defineProperty(exports, "mastraNativeVectorMutation", {
+	enumerable: true,
+	get: function() {
+		return mastraNativeVectorMutation;
+	}
+});
+Object.defineProperty(exports, "mastraNativeVectorQuery", {
+	enumerable: true,
+	get: function() {
+		return mastraNativeVectorQuery;
+	}
+});
+Object.defineProperty(exports, "mastraStorage", {
+	enumerable: true,
+	get: function() {
+		return mastraStorage;
+	}
+});
+
+//# sourceMappingURL=server-13j_f22k.cjs.map