@mastra/convex 1.7.2 → 1.7.3-alpha.1

package/dist/{server-D3SG5LQf.js → server-B8RSiOmu.js}

@@ -550,6 +550,153 @@ function mergeReflectionWithUnreflected(activeObservations, bufferedReflection,
 	const unreflectedContent = (activeObservations || "").split("\n").slice(reflectedLineCount).join("\n").trim();
 	return unreflectedContent ? `${bufferedReflection}\n\n${unreflectedContent}` : bufferedReflection;
 }
+/**
+* A buffered chunk stores `lastObservedAt = max message time + 1ms`; it is wholly covered by
+* the cursor iff `cursor >= chunk.lastObservedAt - 1ms`.
+*/
+function isChunkCoveredByCursor(chunkLastObservedAt, cursor) {
+	if (!cursor) return false;
+	return Date.parse(cursor) >= Date.parse(chunkLastObservedAt) - 1;
+}
+/** The later of two ISO cursors (`null` only when both are absent). */
+function maxCursor(a, b) {
+	if (!a) return b ?? null;
+	if (!b) return a;
+	return Date.parse(b) > Date.parse(a) ? b : a;
+}
+/**
+* New-generation text for a reflection built from `snapshot`: the reflection when the stored
+* text equals the snapshot; the reflection plus the appended tail when the stored text only
+* extends it; `null` (do not apply) after a non-append rewrite.
+*/
+function planReflectionText(input) {
+	const stored = input.storedObservations ?? "";
+	const snapshot = input.snapshotObservations ?? "";
+	if (stored === snapshot) return {
+		observations: input.reflection,
+		tokenCount: input.tokenCount
+	};
+	if (!stored.startsWith(snapshot)) return null;
+	const tail = stored.slice(snapshot.length).trimStart();
+	if (!tail.trim()) return {
+		observations: input.reflection,
+		tokenCount: input.tokenCount
+	};
+	return {
+		observations: input.reflection ? `${input.reflection}\n\n${tail}` : tail,
+		tokenCount: input.tokenCount + Math.max(0, (input.storedObservationTokenCount ?? 0) - (input.snapshotObservationTokenCount ?? 0))
+	};
+}
+/** Whether the stored text equals or only extends the snapshot. */
+function isAppendOnly(storedObservations, snapshotObservations) {
+	const stored = storedObservations ?? "";
+	const snapshot = snapshotObservations ?? "";
+	return stored === snapshot || stored.startsWith(snapshot);
+}
+/** Canonical head order: generationCount DESC, createdAt ASC, id ASC. */
+function sortsBeforeAsHead(a, b) {
+	if (a.generationCount !== b.generationCount) return a.generationCount > b.generationCount;
+	if (a.createdAt !== b.createdAt) return Date.parse(a.createdAt) < Date.parse(b.createdAt);
+	return a.id < b.id;
+}
+/**
+* The canonical head of a lookup key. `by_lookup_key` orders ties by `_creationTime`, so when
+* the top two share a generation all tied rows are read and the canonical order picks one.
+*/
+async function getCanonicalHead(ctx, convexTable, lookupKey) {
+	const top = await ctx.db.query(convexTable).withIndex("by_lookup_key", (q) => q.eq("lookupKey", lookupKey)).order("desc").take(2);
+	if (top.length === 0) return null;
+	if (top.length === 1 || top[1].generationCount !== top[0].generationCount) return top[0];
+	return (await ctx.db.query(convexTable).withIndex("by_lookup_key", (q) => q.eq("lookupKey", lookupKey).eq("generationCount", top[0].generationCount)).collect()).reduce((best, doc) => sortsBeforeAsHead(doc, best) ? doc : best);
+}
+/**
+* Liveness of the record a lifecycle write names. A record with `supersededBy` set is retired.
+* A record that is unmarked but is not its key's canonical head (left by an older adapter
+* version, which never set the marker) is marked superseded by the head here and treated as
+* retired, so a write never lands on it.
+*/
+async function resolveTarget(ctx, convexTable, id, now) {
+	const doc = await findRecordById(ctx, convexTable, id);
+	if (!doc) return { kind: "missing" };
+	const head = await getCanonicalHead(ctx, convexTable, doc.lookupKey);
+	if (doc.supersededBy) return {
+		kind: "retired",
+		doc,
+		head
+	};
+	if (head && head.id !== doc.id) {
+		await ctx.db.patch(doc._id, {
+			supersededBy: head.id,
+			updatedAt: now
+		});
+		return {
+			kind: "retired",
+			doc,
+			head
+		};
+	}
+	return {
+		kind: "live",
+		doc
+	};
+}
+/** The live record a write aimed at `id` lands on (the head when `id` is retired). Throws when missing. */
+async function resolveWriteTarget(ctx, convexTable, id, now) {
+	const target = await resolveTarget(ctx, convexTable, id, now);
+	if (target.kind === "missing") return requireRecord(null, id);
+	if (target.kind === "live") return target.doc;
+	if (!target.head) throw new Error(`Observational memory record ${id} is superseded but no live head was found`);
+	return target.head;
+}
+/**
+* Create the next generation from the stored (live) record and retire it in the same mutation.
+* Buffered chunks move to the new generation; the cursor, buffering markers, flags, and
+* counters carry over; buffered reflection state does not.
+*/
+async function rollOver(ctx, convexTable, stored, args) {
+	const newRecord = {
+		id: args.newId,
+		lookupKey: stored.lookupKey,
+		scope: stored.scope,
+		resourceId: stored.resourceId ?? null,
+		threadId: stored.threadId ?? null,
+		activeObservations: args.observations,
+		activeObservationsPendingUpdate: null,
+		originType: "reflection",
+		config: stored.config,
+		generationCount: Number(stored.generationCount || 0) + 1,
+		lastObservedAt: stored.lastObservedAt ?? null,
+		lastReflectionAt: args.now,
+		pendingMessageTokens: Number(stored.pendingMessageTokens || 0),
+		totalTokensObserved: Number(stored.totalTokensObserved || 0),
+		observationTokenCount: args.tokenCount,
+		isObserving: false,
+		isReflecting: false,
+		bufferedObservationChunks: parseStoredChunks(stored.bufferedObservationChunks).length ? stored.bufferedObservationChunks : null,
+		isBufferingObservation: Boolean(stored.isBufferingObservation),
+		isBufferingReflection: false,
+		lastBufferedAtTokens: Number(stored.lastBufferedAtTokens || 0),
+		lastBufferedAtTime: stored.lastBufferedAtTime ?? null,
+		observedTimezone: stored.observedTimezone ?? null,
+		metadata: stored.metadata ?? null,
+		supersededBy: null,
+		createdAt: args.now,
+		updatedAt: args.now
+	};
+	await ctx.db.insert(convexTable, newRecord);
+	await ctx.db.patch(stored._id, {
+		supersededBy: args.newId,
+		bufferedObservationChunks: null,
+		...args.clearBufferedReflection ? {
+			bufferedReflection: null,
+			bufferedReflectionTokens: null,
+			bufferedReflectionInputTokens: null,
+			reflectedObservationLineCount: null
+		} : {},
+		updatedAt: args.now
+	});
+	return newRecord;
+}
 function isPlainObj(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -595,8 +742,78 @@ 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
+			result: await getCanonicalHead(ctx, convexTable, request.lookupKey)
 		};
+		case "omInitialize": {
+			const existing = await getCanonicalHead(ctx, convexTable, request.record.lookupKey);
+			if (existing) return {
+				ok: true,
+				result: existing
+			};
+			await ctx.db.insert(convexTable, {
+				...request.record,
+				supersededBy: null
+			});
+			return {
+				ok: true,
+				result: {
+					...request.record,
+					supersededBy: null
+				}
+			};
+		}
+		case "omCreateReflectionGeneration": {
+			const { currentRecord, newId, reflection, tokenCount, now } = request;
+			const target = await resolveTarget(ctx, convexTable, currentRecord.id, now);
+			if (target.kind === "missing") return {
+				ok: true,
+				result: null
+			};
+			if (target.kind === "retired") return {
+				ok: true,
+				result: target.head
+			};
+			const stored = target.doc;
+			const plan = planReflectionText({
+				storedObservations: stored.activeObservations || "",
+				storedObservationTokenCount: Number(stored.observationTokenCount || 0),
+				snapshotObservations: currentRecord.activeObservations ?? "",
+				snapshotObservationTokenCount: currentRecord.observationTokenCount ?? 0,
+				reflection,
+				tokenCount
+			});
+			if (!plan) return {
+				ok: true,
+				result: stored
+			};
+			return {
+				ok: true,
+				result: await rollOver(ctx, convexTable, stored, {
+					newId,
+					observations: plan.observations,
+					tokenCount: plan.tokenCount,
+					now,
+					clearBufferedReflection: false
+				})
+			};
+		}
+		case "omSetPendingMessageTokens": {
+			const doc = await resolveWriteTarget(ctx, convexTable, request.id, request.updatedAt);
+			await ctx.db.patch(doc._id, {
+				pendingMessageTokens: request.tokenCount,
+				updatedAt: request.updatedAt
+			});
+			return { ok: true };
+		}
+		case "omSetBufferingObservationFlag": {
+			const doc = await resolveWriteTarget(ctx, convexTable, request.id, request.updatedAt);
+			await ctx.db.patch(doc._id, {
+				isBufferingObservation: request.isBuffering,
+				...request.lastBufferedAtTokens !== void 0 ? { lastBufferedAtTokens: request.lastBufferedAtTokens } : {},
+				updatedAt: request.updatedAt
+			});
+			return { ok: true };
+		}
 		case "omGetHistory": {
 			let docs = request.recordId !== void 0 ? [await findRecordById(ctx, convexTable, request.recordId)].filter((doc) => doc?.lookupKey === request.lookupKey) : await ctx.db.query(convexTable).withIndex("by_lookup_key", (q) => {
 				let range = q.eq("lookupKey", request.lookupKey);
@@ -621,39 +838,82 @@ async function handleObservationalMemoryOperation(ctx, convexTable, request) {
 			};
 		}
 		case "omUpdateActive": {
-			const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+			const target = await resolveTarget(ctx, convexTable, request.id, request.updatedAt);
+			if (target.kind === "missing") requireRecord(null, request.id);
+			if (target.kind !== "live") return {
+				ok: true,
+				result: {
+					applied: false,
+					reason: "retired"
+				}
+			};
+			const doc = target.doc;
+			if (request.expectedActiveObservations !== void 0 && request.expectedActiveObservations !== (doc.activeObservations || "")) return {
+				ok: true,
+				result: {
+					applied: false,
+					reason: "conflict"
+				}
+			};
 			const safeTokenCount = Number.isFinite(request.tokenCount) && request.tokenCount >= 0 ? request.tokenCount : 0;
 			await ctx.db.patch(doc._id, {
 				activeObservations: request.observations,
-				lastObservedAt: request.lastObservedAt,
+				lastObservedAt: maxCursor(doc.lastObservedAt, request.lastObservedAt),
 				pendingMessageTokens: 0,
 				observationTokenCount: safeTokenCount,
 				totalTokensObserved: Number(doc.totalTokensObserved || 0) + safeTokenCount,
 				observedMessageIds: request.observedMessageIds,
 				updatedAt: request.updatedAt
 			});
-			return { ok: true };
+			return {
+				ok: true,
+				result: { applied: true }
+			};
 		}
 		case "omAppendBufferedChunk": {
-			const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+			const doc = await resolveWriteTarget(ctx, convexTable, request.id, request.updatedAt);
 			const chunks = parseStoredChunks(doc.bufferedObservationChunks);
+			if (chunks.some((chunk) => chunk.cycleId === request.chunk.cycleId) || isChunkCoveredByCursor(request.chunk.lastObservedAt, doc.lastObservedAt)) return {
+				ok: true,
+				result: {
+					persisted: false,
+					recordId: doc.id
+				}
+			};
 			chunks.push(request.chunk);
-			const patch = {
+			await ctx.db.patch(doc._id, {
 				bufferedObservationChunks: JSON.stringify(chunks),
+				lastBufferedAtTime: maxCursor(doc.lastBufferedAtTime, request.lastBufferedAtTime),
 				updatedAt: request.updatedAt
+			});
+			return {
+				ok: true,
+				result: {
+					persisted: true,
+					recordId: doc.id
+				}
 			};
-			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 {
+			const target = await resolveTarget(ctx, convexTable, request.id, request.now);
+			if (target.kind === "missing") requireRecord(null, request.id);
+			if (target.kind !== "live") return {
 				ok: true,
-				result: EMPTY_SWAP_RESULT
+				result: {
+					...EMPTY_SWAP_RESULT,
+					retired: true
+				}
 			};
-			const chunks = Array.isArray(request.bufferedChunks) ? request.bufferedChunks : persistedChunks;
+			const doc = target.doc;
+			const refreshedWeights = new Map((request.bufferedChunks ?? []).map((chunk) => [chunk.id, chunk.messageTokens]));
+			const storedChunks = parseStoredChunks(doc.bufferedObservationChunks);
+			const chunks = storedChunks.map((chunk) => {
+				const weight = refreshedWeights.get(chunk.id);
+				return weight === void 0 ? chunk : {
+					...chunk,
+					messageTokens: weight
+				};
+			});
 			if (chunks.length === 0) return {
 				ok: true,
 				result: EMPTY_SWAP_RESULT
@@ -665,7 +925,7 @@ async function handleObservationalMemoryOperation(ctx, convexTable, request) {
 				forceMaxActivation: request.forceMaxActivation
 			});
 			const activatedChunks = chunks.slice(0, chunksToActivate);
-			const remainingChunks = chunks.slice(chunksToActivate);
+			const remainingChunks = storedChunks.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);
@@ -682,7 +942,7 @@ async function handleObservationalMemoryOperation(ctx, convexTable, request) {
 				observationTokenCount: Number(doc.observationTokenCount || 0) + activatedTokens,
 				pendingMessageTokens: Math.max(0, Number(doc.pendingMessageTokens || 0) - activatedMessageTokens),
 				bufferedObservationChunks: remainingChunks.length > 0 ? JSON.stringify(remainingChunks) : null,
-				lastObservedAt,
+				lastObservedAt: maxCursor(doc.lastObservedAt, lastObservedAt),
 				updatedAt: request.now
 			});
 			const latestChunkHints = activatedChunks[activatedChunks.length - 1];
@@ -722,48 +982,32 @@ async function handleObservationalMemoryOperation(ctx, convexTable, request) {
 		}
 		case "omSwapBufferedReflection": {
 			const { currentRecord, newId, tokenCount, now } = request;
-			const doc = requireRecord(await findRecordById(ctx, convexTable, currentRecord.id), currentRecord.id);
-			const bufferedReflection = doc.bufferedReflection || "";
+			const target = await resolveTarget(ctx, convexTable, currentRecord.id, now);
+			if (target.kind === "missing") return {
+				ok: true,
+				result: null
+			};
+			if (target.kind === "retired") return {
+				ok: true,
+				result: target.head
+			};
+			const stored = target.doc;
+			const bufferedReflection = stored.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
+			const storedObservations = stored.activeObservations || "";
+			if (!isAppendOnly(storedObservations, currentRecord.activeObservations ?? "")) return {
+				ok: true,
+				result: stored
 			};
-			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
+				result: await rollOver(ctx, convexTable, stored, {
+					newId,
+					observations: mergeReflectionWithUnreflected(storedObservations, bufferedReflection, Number(stored.reflectedObservationLineCount || 0)),
+					tokenCount: tokenCount + Math.max(0, Number(stored.observationTokenCount || 0) - (currentRecord.observationTokenCount ?? 0)),
+					now,
+					clearBufferedReflection: true
+				})
 			};
 		}
 		case "omUpdateConfig": {
@@ -778,6 +1022,152 @@ async function handleObservationalMemoryOperation(ctx, convexTable, request) {
 	}
 }
 //#endregion
+//#region src/server/run-fencing.ts
+const RUN_FENCE_CONFLICT_CODE = "STORAGE_RUN_FENCE_CONFLICT";
+const RUN_CLAIM_OPS = /* @__PURE__ */ new Set([
+	"claimRunOwnership",
+	"renewRunOwnership",
+	"releaseRunOwnership",
+	"getRunOwnership",
+	"raiseRunFence",
+	"retireRunFence",
+	"fenced"
+]);
+const RUN_CLAIM_TABLES = /* @__PURE__ */ new Set(["mastra_workflow_run_owners", "mastra_memory_run_fences"]);
+const CLAIMS_TABLE = "mastra_documents";
+function isRunClaimRequest(request) {
+	return RUN_CLAIM_OPS.has(request.op);
+}
+async function findClaim(ctx, table, runId) {
+	return ctx.db.query(CLAIMS_TABLE).withIndex("by_table_primary", (q) => q.eq("table", table).eq("primaryKey", runId)).unique();
+}
+async function writeClaim(ctx, table, doc, claim) {
+	const record = {
+		id: claim.runId,
+		...claim
+	};
+	if (doc) await ctx.db.patch(doc._id, { record });
+	else await ctx.db.insert(CLAIMS_TABLE, {
+		table,
+		primaryKey: claim.runId,
+		record
+	});
+	return claim;
+}
+function holds(claim, fence) {
+	return claim !== null && claim.generation === fence.generation && claim.ownerId === fence.ownerId;
+}
+function reply(applied, claim, now) {
+	return {
+		ok: true,
+		result: {
+			applied,
+			claim,
+			now
+		}
+	};
+}
+/**
+* Runs a run fencing operation. Each reads and writes the run's claim in the
+* calling mutation, so Convex serializes it against every other claim
+* operation and fenced write on the same run. Leases are measured on the
+* mutation's clock.
+*
+* `route` runs the request a fenced operation wraps.
+*/
+async function handleRunClaimOperation(ctx, request, route) {
+	if (!RUN_CLAIM_TABLES.has(request.tableName)) return {
+		ok: false,
+		error: `Unsupported run claim table ${request.tableName}`
+	};
+	const now = Date.now();
+	switch (request.op) {
+		case "claimRunOwnership": {
+			const { tableName, runId, ownerId, leaseMs, force, expectedGeneration } = request;
+			const doc = await findClaim(ctx, tableName, runId);
+			const current = doc?.record ?? null;
+			const leaseExpiresAt = now + leaseMs;
+			if (!current) {
+				if (expectedGeneration !== void 0 && expectedGeneration !== 0) return reply(false, null, now);
+				return reply(true, await writeClaim(ctx, tableName, doc, {
+					runId,
+					generation: Math.max(1, now),
+					ownerId,
+					leaseExpiresAt,
+					updatedAt: now
+				}), now);
+			}
+			if (expectedGeneration !== void 0 && current.generation !== expectedGeneration) return reply(false, current, now);
+			if (!force && current.leaseExpiresAt !== null && current.leaseExpiresAt > now) return reply(false, current, now);
+			return reply(true, await writeClaim(ctx, tableName, doc, {
+				runId,
+				generation: current.generation + 1,
+				ownerId,
+				leaseExpiresAt,
+				updatedAt: now
+			}), now);
+		}
+		case "renewRunOwnership": {
+			const { tableName, fence, leaseMs } = request;
+			const doc = await findClaim(ctx, tableName, fence.runId);
+			const current = doc?.record ?? null;
+			if (!holds(current, fence) || current.leaseExpiresAt === null) return reply(false, current, now);
+			return reply(true, await writeClaim(ctx, tableName, doc, {
+				...current,
+				leaseExpiresAt: now + leaseMs,
+				updatedAt: now
+			}), now);
+		}
+		case "releaseRunOwnership": {
+			const { tableName, fence } = request;
+			const doc = await findClaim(ctx, tableName, fence.runId);
+			const current = doc?.record ?? null;
+			if (!holds(current, fence)) return reply(false, current, now);
+			return reply(true, await writeClaim(ctx, tableName, doc, {
+				...current,
+				leaseExpiresAt: null,
+				updatedAt: now
+			}), now);
+		}
+		case "getRunOwnership": return reply(true, (await findClaim(ctx, request.tableName, request.runId))?.record ?? null, now);
+		case "raiseRunFence": {
+			const { tableName, fence } = request;
+			const doc = await findClaim(ctx, tableName, fence.runId);
+			const current = doc?.record ?? null;
+			if (!current || current.generation < fence.generation || holds(current, fence)) return reply(true, await writeClaim(ctx, tableName, doc, {
+				...fence,
+				leaseExpiresAt: null,
+				retiredAt: null
+			}), now);
+			return reply(false, current, now);
+		}
+		case "retireRunFence": {
+			const { tableName, fence } = request;
+			const doc = await findClaim(ctx, tableName, fence.runId);
+			const current = doc?.record ?? null;
+			if (!holds(current, fence)) return reply(false, current, now);
+			return reply(true, await writeClaim(ctx, tableName, doc, {
+				...current,
+				retiredAt: now
+			}), now);
+		}
+		case "fenced": {
+			const { tableName, fence, request: inner } = request;
+			if (!holds((await findClaim(ctx, tableName, fence.runId))?.record ?? null, fence)) return {
+				ok: false,
+				error: `Run ${fence.runId} is no longer claimed by generation ${fence.generation} of ${fence.ownerId}`,
+				code: RUN_FENCE_CONFLICT_CODE
+			};
+			if (!inner) return { ok: true };
+			if (RUN_CLAIM_OPS.has(inner.op)) return {
+				ok: false,
+				error: `Unsupported fenced operation ${inner.op}`
+			};
+			return route(ctx, inner);
+		}
+	}
+}
+//#endregion
 //#region src/server/workflow-snapshot.ts
 const PENDING_MARKER_KEY = "__mastra_pending__";
 function isPendingMarker(val) {
@@ -1059,6 +1449,10 @@ function resolveTable(tableName) {
 * Routes operations to the appropriate typed table.
 */
 const mastraStorage = mutationGeneric(async (ctx, request) => {
+	if (isRunClaimRequest(request)) return handleRunClaimOperation(ctx, request, routeStorageRequest);
+	return routeStorageRequest(ctx, request);
+});
+async function routeStorageRequest(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);
@@ -1078,7 +1472,7 @@ const mastraStorage = mutationGeneric(async (ctx, request) => {
 			error: error.message
 		};
 	}
-});
+}
 function parseStoredSnapshot(stored, runId) {
 	if (typeof stored === "string") return JSON.parse(stored);
 	return JSON.parse(JSON.stringify(stored ?? createEmptyWorkflowSnapshot(runId)));
@@ -1108,6 +1502,10 @@ async function handleTypedOperation(ctx, convexTable, request) {
 	switch (request.op) {
 		case "omGetLatest":
 		case "omGetHistory":
+		case "omInitialize":
+		case "omCreateReflectionGeneration":
+		case "omSetPendingMessageTokens":
+		case "omSetBufferingObservationFlag":
 		case "omUpdateActive":
 		case "omAppendBufferedChunk":
 		case "omSwapBuffered":
@@ -1895,4 +2293,4 @@ const mastraNativeVectorMutation = mutationGeneric({
 //#endregion
 export { mastraCache as a, mastraStorage as i, mastraNativeVectorMutation as n, mastraNativeVectorQuery as r, mastraNativeVectorAction as t };
 
-//# sourceMappingURL=server-D3SG5LQf.js.map
+//# sourceMappingURL=server-B8RSiOmu.js.map