@mastra/mssql 1.10.2 → 1.10.3

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-mssql
 description: Documentation for @mastra/mssql. Use when working with @mastra/mssql APIs, configuration, or implementation.
 metadata:
   package: "@mastra/mssql"
-  version: "1.10.2"
+  version: "1.10.3"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.10.2",
+  "version": "1.10.3",
   "package": "@mastra/mssql",
   "exports": {},
   "modules": {}

package/dist/index.cjs

@@ -2127,6 +2127,73 @@ var BackgroundTasksMSSQL = class BackgroundTasksMSSQL extends _mastra_core_stora
 	}
 };
 //#endregion
+//#region src/storage/db/run-fencing.ts
+/**
+* Epoch milliseconds on the database clock. SQL Server evaluates
+* `SYSUTCDATETIME()` once when a statement starts, so a statement that waits
+* on a lock compares against the time it started. That error only makes an
+* existing lease look longer and a new lease shorter.
+*/
+const DB_NOW_MS = `DATEDIFF_BIG(MILLISECOND, '1970-01-01', SYSUTCDATETIME())`;
+const ERR_DEADLOCK_VICTIM = 1205;
+const ERR_UNIQUE_INDEX = 2601;
+const ERR_PRIMARY_KEY = 2627;
+const MAX_CLAIM_ATTEMPTS = 5;
+/**
+* The check half of a fenced write; call it first inside the write's
+* transaction. `HOLDLOCK` keeps the shared lock on the claim row until commit,
+* even on databases with read-committed snapshot on, so a claim that updates
+* the row waits for the write to finish, and every later write sees the new
+* claim.
+*/
+async function assertRunFence(q, claimsTable, fence, operation) {
+	const row = (await q.request().input("runId", fence.runId).query(`SELECT [generation], [ownerId] FROM ${claimsTable} WITH (HOLDLOCK) WHERE [runId] = @runId`)).recordset[0];
+	if (!(0, _mastra_core_storage.matchesRunFence)(row ? {
+		generation: Number(row.generation),
+		ownerId: String(row.ownerId)
+	} : null, fence)) throw new _mastra_core_storage.RunFenceConflictError(fence, operation);
+}
+/** Runs `fn` in a transaction. */
+async function inTransaction(pool, fn) {
+	const transaction = pool.transaction();
+	await transaction.begin();
+	try {
+		const result = await fn(transaction);
+		await transaction.commit();
+		return result;
+	} catch (error) {
+		await transaction.rollback().catch(() => {});
+		throw error;
+	}
+}
+/**
+* Runs `write` directly when it carries no fence, or in a transaction behind
+* the fence check when it does.
+*/
+function withRunFence(pool, claimsTable, fence, operation, write) {
+	if (!fence) return write(pool);
+	return inTransaction(pool, async (transaction) => {
+		await assertRunFence(transaction, claimsTable, fence, operation);
+		return write(transaction);
+	});
+}
+/**
+* Runs a transaction that creates or updates a run's claim row, retrying when
+* two first claims race to insert it. Claims read the row with
+* `UPDLOCK, HOLDLOCK`, which locks the key range of a missing row, so racing
+* first claims normally queue; the retry covers a deadlock victim or a
+* duplicate key if they don't. On retry the row exists and the claim
+* serializes behind its row lock.
+*/
+async function claimTransaction(pool, fn) {
+	for (let attempt = 1;; attempt++) try {
+		return await inTransaction(pool, fn);
+	} catch (error) {
+		const number = error.number;
+		if (attempt >= MAX_CLAIM_ATTEMPTS || !(number === ERR_DEADLOCK_VICTIM || number === ERR_PRIMARY_KEY || number === ERR_UNIQUE_INDEX)) throw error;
+	}
+}
+//#endregion
 //#region src/storage/domains/memory/index.ts
 function bindMssqlMetadataParams(request, params) {
 	for (const [paramName, paramValue] of Object.entries(params)) request.input(paramName, paramValue);
@@ -2216,9 +2283,69 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 			tableName: _mastra_core_storage.TABLE_RESOURCES,
 			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_RESOURCES]
 		});
+		await this.db.createTable({
+			tableName: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES,
+			schema: _mastra_core_storage.RUN_FENCING_TABLE_SCHEMAS[_mastra_core_storage.TABLE_MEMORY_RUN_FENCES]
+		});
 		await this.createDefaultIndexes();
 		await this.createCustomIndexes();
 	}
+	supportsRunFencing() {
+		return true;
+	}
+	get #runFencesTable() {
+		return getTableName({
+			indexName: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES,
+			schemaName: getSchemaName(this.schema)
+		});
+	}
+	async raiseRunFence(fence) {
+		const table = this.#runFencesTable;
+		try {
+			return await claimTransaction(this.pool, async (transaction) => {
+				const row = (await transaction.request().input("runId", fence.runId).query(`SELECT [generation], [ownerId] FROM ${table} WITH (UPDLOCK, HOLDLOCK) WHERE [runId] = @runId`)).recordset[0];
+				if (!row) {
+					await transaction.request().input("runId", fence.runId).input("generation", mssql.default.BigInt, fence.generation).input("ownerId", fence.ownerId).query(`INSERT INTO ${table} ([runId], [generation], [ownerId]) VALUES (@runId, @generation, @ownerId)`);
+					return true;
+				}
+				const generation = Number(row.generation);
+				const raises = generation < fence.generation;
+				const reaffirms = generation === fence.generation && String(row.ownerId) === fence.ownerId;
+				if (!raises && !reaffirms) return false;
+				await transaction.request().input("runId", fence.runId).input("generation", mssql.default.BigInt, fence.generation).input("ownerId", fence.ownerId).query(`UPDATE ${table} SET [generation] = @generation, [ownerId] = @ownerId, [retiredAt] = NULL WHERE [runId] = @runId`);
+				return true;
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("MSSQL", "RAISE_RUN_FENCE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { runId: fence.runId }
+			}, error);
+		}
+	}
+	async retireRunFence(fence) {
+		try {
+			return (await this.pool.request().input("runId", fence.runId).input("generation", mssql.default.BigInt, fence.generation).input("ownerId", fence.ownerId).query(`UPDATE ${this.#runFencesTable} SET [retiredAt] = ${DB_NOW_MS}
+           WHERE [runId] = @runId AND [generation] = @generation AND [ownerId] = @ownerId`)).rowsAffected[0] === 1;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("MSSQL", "RETIRE_RUN_FENCE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { runId: fence.runId }
+			}, error);
+		}
+	}
+	/** Runs `write` behind its own fence, otherwise the one in scope for this store. */
+	#fenced(fence, operation, write) {
+		return withRunFence(this.pool, this.#runFencesTable, (0, _mastra_core_storage.resolveRunFence)(this, fence), operation, write);
+	}
+	/** The fence check for a write that already runs in its own transaction. */
+	async #assertFence(transaction, fence, operation) {
+		const resolved = (0, _mastra_core_storage.resolveRunFence)(this, fence);
+		if (resolved) await assertRunFence(transaction, this.#runFencesTable, resolved, operation);
+	}
 	/**
 	* Returns default index definitions for the memory domain tables.
 	* IMPORTANT: Uses seq_id DESC instead of createdAt DESC for MSSQL due to millisecond accuracy limitations
@@ -2261,6 +2388,7 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 		await this.db.clearTable({ tableName: _mastra_core_storage.TABLE_MESSAGES });
 		await this.db.clearTable({ tableName: _mastra_core_storage.TABLE_THREADS });
 		await this.db.clearTable({ tableName: _mastra_core_storage.TABLE_RESOURCES });
+		await this.db.clearTable({ tableName: _mastra_core_storage.TABLE_MEMORY_RUN_FENCES });
 	}
 	async getThreadById({ threadId, resourceId }) {
 		try {
@@ -2411,7 +2539,7 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 			throw mastraError;
 		}
 	}
-	async saveThread({ thread }) {
+	async saveThread({ thread, fence }) {
 		try {
 			const mergeSql = `MERGE INTO ${getTableName({
 				indexName: _mastra_core_storage.TABLE_THREADS,
@@ -2428,18 +2556,21 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
         WHEN NOT MATCHED THEN
           INSERT (id, [resourceId], title, metadata, [createdAt], [updatedAt])
           VALUES (@id, @resourceId, @title, @metadata, @createdAt, @updatedAt);`;
-			const req = this.pool.request();
-			req.input("id", thread.id);
-			req.input("resourceId", thread.resourceId);
-			req.input("title", thread.title);
 			const metadata = thread.metadata ? JSON.stringify(thread.metadata) : null;
-			if (metadata === null) req.input("metadata", mssql.default.NVarChar, null);
-			else req.input("metadata", metadata);
-			req.input("createdAt", mssql.default.DateTime2, thread.createdAt);
-			req.input("updatedAt", mssql.default.DateTime2, thread.updatedAt);
-			await req.query(mergeSql);
+			await this.#fenced(fence, "saveThread", (q) => {
+				const req = q.request();
+				req.input("id", thread.id);
+				req.input("resourceId", thread.resourceId);
+				req.input("title", thread.title);
+				if (metadata === null) req.input("metadata", mssql.default.NVarChar, null);
+				else req.input("metadata", metadata);
+				req.input("createdAt", mssql.default.DateTime2, thread.createdAt);
+				req.input("updatedAt", mssql.default.DateTime2, thread.updatedAt);
+				return req.query(mergeSql);
+			});
 			return thread;
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MSSQL", "SAVE_THREAD", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -2451,7 +2582,7 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 	/**
 	* Updates a thread's title and metadata, merging with existing metadata. Returns the updated thread.
 	*/
-	async updateThread({ id, title, metadata }) {
+	async updateThread({ id, title, metadata, fence }) {
 		const existingThread = await this.getThreadById({ threadId: id });
 		if (!existingThread) throw new _mastra_core_error.MastraError({
 			id: (0, _mastra_core_storage.createStorageErrorId)("MSSQL", "UPDATE_THREAD", "NOT_FOUND"),
@@ -2477,12 +2608,7 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
             [updatedAt] = @updatedAt
         OUTPUT INSERTED.*
         WHERE id = @id`;
-			const req = this.pool.request();
-			req.input("id", id);
-			req.input("title", title ?? existingThread.title);
-			req.input("metadata", JSON.stringify(mergedMetadata));
-			req.input("updatedAt", /* @__PURE__ */ new Date());
-			const result = await req.query(sql);
+			const result = await this.#fenced(fence, "updateThread", (q) => q.request().input("id", id).input("title", title ?? existingThread.title).input("metadata", JSON.stringify(mergedMetadata)).input("updatedAt", /* @__PURE__ */ new Date()).query(sql));
 			let thread = result.recordset && result.recordset[0];
 			if (thread && "seq_id" in thread) {
 				const { seq_id, ...rest } = thread;
@@ -2505,6 +2631,7 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 				updatedAt: thread.updatedAt
 			};
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MSSQL", "UPDATE_THREAD", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -2870,7 +2997,7 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 			throw mastraError;
 		}
 	}
-	async saveMessages({ messages }) {
+	async saveMessages({ messages, fence }) {
 		if (messages.length === 0) return { messages: [] };
 		const threadId = messages[0]?.threadId;
 		if (!threadId) throw new _mastra_core_error.MastraError({
@@ -2898,6 +3025,7 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 			const transaction = this.pool.transaction();
 			await transaction.begin();
 			try {
+				await this.#assertFence(transaction, fence, "saveMessages");
 				for (const message of messages) {
 					if (!message.threadId) throw new Error(`Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`);
 					if (!message.resourceId) throw new Error(`Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`);
@@ -2945,6 +3073,7 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 			});
 			return { messages: new _mastra_core_agent.MessageList().add(messagesWithParsedContent, "memory").get.all.db() };
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MSSQL", "SAVE_MESSAGES", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -2953,7 +3082,7 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 			}, error);
 		}
 	}
-	async updateMessages({ messages }) {
+	async updateMessages({ messages, fence }) {
 		if (!messages || messages.length === 0) return [];
 		const messageIds = messages.map((m) => m.id);
 		const idParams = messageIds.map((_, i) => `@id${i}`).join(", ");
@@ -2977,6 +3106,7 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 		const transaction = this.pool.transaction();
 		try {
 			await transaction.begin();
+			await this.#assertFence(transaction, fence, "updateMessages");
 			for (const existingMessage of existingMessages) {
 				const updatePayload = messages.find((m) => m.id === existingMessage.id);
 				if (!updatePayload) continue;
@@ -3029,6 +3159,7 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 			await transaction.commit();
 		} catch (error) {
 			await transaction.rollback();
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MSSQL", "UPDATE_MESSAGES", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -3044,7 +3175,7 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 			return message;
 		});
 	}
-	async deleteMessages(messageIds) {
+	async deleteMessages(messageIds, options) {
 		if (!messageIds || messageIds.length === 0) return;
 		try {
 			const messageTableName = getTableName({
@@ -3064,6 +3195,7 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 			const transaction = this.pool.transaction();
 			await transaction.begin();
 			try {
+				await this.#assertFence(transaction, options?.fence, "deleteMessages");
 				const deleteRequest = transaction.request();
 				messageIds.forEach((id, idx) => {
 					deleteRequest.input(`p${idx + 1}`, id);
@@ -3082,6 +3214,7 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 				throw error;
 			}
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MSSQL", "DELETE_MESSAGES", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -3129,7 +3262,7 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 		});
 		return resource;
 	}
-	async updateResource({ resourceId, workingMemory, metadata }) {
+	async updateResource({ resourceId, workingMemory, metadata, fence }) {
 		try {
 			const existingResource = await this.getResourceById({ resourceId });
 			if (!existingResource) {
@@ -3140,7 +3273,12 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 					createdAt: /* @__PURE__ */ new Date(),
 					updatedAt: /* @__PURE__ */ new Date()
 				};
-				return this.saveResource({ resource: newResource });
+				await this.#fenced(fence, "updateResource", (q) => this.db.insert({
+					tableName: _mastra_core_storage.TABLE_RESOURCES,
+					record: newResource,
+					transaction: q
+				}));
+				return newResource;
 			}
 			const updatedResource = {
 				...existingResource,
@@ -3155,22 +3293,25 @@ var MemoryMSSQL = class MemoryMSSQL extends _mastra_core_storage.MemoryStorage {
 				indexName: _mastra_core_storage.TABLE_RESOURCES,
 				schemaName: getSchemaName(this.schema)
 			});
-			const updates = [];
-			const req = this.pool.request();
-			if (workingMemory !== void 0) {
-				updates.push("workingMemory = @workingMemory");
-				req.input("workingMemory", workingMemory);
-			}
-			if (metadata) {
-				updates.push("metadata = @metadata");
-				req.input("metadata", JSON.stringify(updatedResource.metadata));
-			}
-			updates.push("updatedAt = @updatedAt");
-			req.input("updatedAt", updatedResource.updatedAt.toISOString());
-			req.input("id", resourceId);
-			await req.query(`UPDATE ${tableName} SET ${updates.join(", ")} WHERE id = @id`);
+			await this.#fenced(fence, "updateResource", (q) => {
+				const updates = [];
+				const req = q.request();
+				if (workingMemory !== void 0) {
+					updates.push("workingMemory = @workingMemory");
+					req.input("workingMemory", workingMemory);
+				}
+				if (metadata) {
+					updates.push("metadata = @metadata");
+					req.input("metadata", JSON.stringify(updatedResource.metadata));
+				}
+				updates.push("updatedAt = @updatedAt");
+				req.input("updatedAt", updatedResource.updatedAt.toISOString());
+				req.input("id", resourceId);
+				return req.query(`UPDATE ${tableName} SET ${updates.join(", ")} WHERE id = @id`);
+			});
 			return updatedResource;
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			const mastraError = new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MSSQL", "UPDATE_RESOURCE", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -4447,6 +4588,17 @@ var WorkflowDefinitionsMSSQL = class WorkflowDefinitionsMSSQL extends _mastra_co
 };
 //#endregion
 //#region src/storage/domains/workflows/index.ts
+const RUN_OWNER_COLUMNS = `[generation], [ownerId], [leaseExpiresAt], ${DB_NOW_MS} AS [nowMs]`;
+function toRunOwnershipRecord(runId, row) {
+	const leaseExpiresAt = row.leaseExpiresAt === null ? null : Number(row.leaseExpiresAt);
+	return {
+		runId,
+		generation: Number(row.generation),
+		ownerId: String(row.ownerId),
+		leaseExpiresAt: leaseExpiresAt === null ? null : new Date(leaseExpiresAt),
+		live: leaseExpiresAt !== null && leaseExpiresAt > Number(row.nowMs)
+	};
+}
 var WorkflowsMSSQL = class WorkflowsMSSQL extends _mastra_core_storage.WorkflowsStorage {
 	pool;
 	db;
@@ -4496,6 +4648,10 @@ var WorkflowsMSSQL = class WorkflowsMSSQL extends _mastra_core_storage.Workflows
 			tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT]
 		});
+		await this.db.createTable({
+			tableName: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS,
+			schema: _mastra_core_storage.RUN_FENCING_TABLE_SCHEMAS[_mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS]
+		});
 		await this.createDefaultIndexes();
 		await this.createCustomIndexes();
 	}
@@ -4512,6 +4668,98 @@ var WorkflowsMSSQL = class WorkflowsMSSQL extends _mastra_core_storage.Workflows
 	}
 	async dangerouslyClearAll() {
 		await this.db.clearTable({ tableName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT });
+		await this.db.clearTable({ tableName: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS });
+	}
+	get #runOwnersTable() {
+		return getTableName({
+			indexName: _mastra_core_storage.TABLE_WORKFLOW_RUN_OWNERS,
+			schemaName: getSchemaName(this.schema)
+		});
+	}
+	async #readRunOwner(q, runId) {
+		const row = (await q.request().input("runId", runId).query(`SELECT ${RUN_OWNER_COLUMNS} FROM ${this.#runOwnersTable} WHERE [runId] = @runId`)).recordset[0];
+		return row ? toRunOwnershipRecord(runId, row) : null;
+	}
+	supportsRunFencing() {
+		return true;
+	}
+	#ownershipError(operation, runId, error) {
+		return new _mastra_core_error.MastraError({
+			id: (0, _mastra_core_storage.createStorageErrorId)("MSSQL", operation, "FAILED"),
+			domain: _mastra_core_error.ErrorDomain.STORAGE,
+			category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+			details: { runId }
+		}, error);
+	}
+	async claimRunOwnership({ runId, ownerId, leaseMs, force, expectedGeneration }) {
+		const table = this.#runOwnersTable;
+		try {
+			return await claimTransaction(this.pool, async (transaction) => {
+				if ((await transaction.request().input("runId", runId).query(`SELECT [generation] FROM ${table} WITH (UPDLOCK, HOLDLOCK) WHERE [runId] = @runId`)).recordset.length === 0) {
+					if (expectedGeneration !== void 0 && expectedGeneration !== 0) return {
+						acquired: false,
+						record: null
+					};
+					await transaction.request().input("runId", runId).input("ownerId", ownerId).input("leaseMs", mssql.default.BigInt, leaseMs).query(`INSERT INTO ${table} ([runId], [generation], [ownerId], [leaseExpiresAt], [updatedAt])
+               VALUES (@runId, ${DB_NOW_MS}, @ownerId, ${DB_NOW_MS} + @leaseMs, ${DB_NOW_MS})`);
+					return {
+						acquired: true,
+						record: await this.#readRunOwner(transaction, runId)
+					};
+				}
+				const updated = await transaction.request().input("runId", runId).input("ownerId", ownerId).input("leaseMs", mssql.default.BigInt, leaseMs).input("expectedGeneration", mssql.default.BigInt, expectedGeneration ?? null).input("force", mssql.default.Bit, force === true).query(`UPDATE ${table}
+             SET [generation] = [generation] + 1, [ownerId] = @ownerId, [leaseExpiresAt] = ${DB_NOW_MS} + @leaseMs,
+                 [updatedAt] = ${DB_NOW_MS}
+             WHERE [runId] = @runId
+               AND (@expectedGeneration IS NULL OR [generation] = @expectedGeneration)
+               AND (@force = 1 OR [leaseExpiresAt] IS NULL OR [leaseExpiresAt] <= ${DB_NOW_MS})`);
+				const record = await this.#readRunOwner(transaction, runId);
+				return updated.rowsAffected[0] === 1 && record ? {
+					acquired: true,
+					record
+				} : {
+					acquired: false,
+					record
+				};
+			});
+		} catch (error) {
+			throw this.#ownershipError("CLAIM_RUN_OWNERSHIP", runId, error);
+		}
+	}
+	async renewRunOwnership({ leaseMs, ...fence }) {
+		try {
+			return await inTransaction(this.pool, async (transaction) => {
+				const updated = await transaction.request().input("runId", fence.runId).input("generation", mssql.default.BigInt, fence.generation).input("ownerId", fence.ownerId).input("leaseMs", mssql.default.BigInt, leaseMs).query(`UPDATE ${this.#runOwnersTable}
+             SET [leaseExpiresAt] = ${DB_NOW_MS} + @leaseMs, [updatedAt] = ${DB_NOW_MS}
+             WHERE [runId] = @runId AND [generation] = @generation AND [ownerId] = @ownerId
+               AND [leaseExpiresAt] IS NOT NULL`);
+				const record = await this.#readRunOwner(transaction, fence.runId);
+				return updated.rowsAffected[0] === 1 && record ? {
+					renewed: true,
+					record
+				} : {
+					renewed: false,
+					record
+				};
+			});
+		} catch (error) {
+			throw this.#ownershipError("RENEW_RUN_OWNERSHIP", fence.runId, error);
+		}
+	}
+	async releaseRunOwnership(fence) {
+		try {
+			return (await this.pool.request().input("runId", fence.runId).input("generation", mssql.default.BigInt, fence.generation).input("ownerId", fence.ownerId).query(`UPDATE ${this.#runOwnersTable} SET [leaseExpiresAt] = NULL, [updatedAt] = ${DB_NOW_MS}
+           WHERE [runId] = @runId AND [generation] = @generation AND [ownerId] = @ownerId`)).rowsAffected[0] === 1;
+		} catch (error) {
+			throw this.#ownershipError("RELEASE_RUN_OWNERSHIP", fence.runId, error);
+		}
+	}
+	async getRunOwnership({ runId }) {
+		try {
+			return await this.#readRunOwner(this.pool, runId);
+		} catch (error) {
+			throw this.#ownershipError("GET_RUN_OWNERSHIP", runId, error);
+		}
 	}
 	parseWorkflowRun(row) {
 		let parsedSnapshot = row.snapshot;
@@ -4529,14 +4777,16 @@ var WorkflowsMSSQL = class WorkflowsMSSQL extends _mastra_core_storage.Workflows
 			resourceId: row.resourceId
 		};
 	}
-	async updateWorkflowResults({ workflowName, runId, stepId, result, requestContext, state }) {
+	async updateWorkflowResults({ workflowName, runId, stepId, result, requestContext, state, fence: explicitFence }) {
 		const table = getTableName({
 			indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 			schemaName: getSchemaName(this.schema)
 		});
+		const fence = (0, _mastra_core_storage.resolveRunFence)(this, explicitFence, runId);
 		const transaction = this.pool.transaction();
 		try {
 			await transaction.begin();
+			if (fence) await assertRunFence(transaction, this.#runOwnersTable, fence, "updateWorkflowResults");
 			const selectRequest = new mssql.default.Request(transaction);
 			selectRequest.input("workflow_name", workflowName);
 			selectRequest.input("run_id", runId);
@@ -4584,6 +4834,7 @@ var WorkflowsMSSQL = class WorkflowsMSSQL extends _mastra_core_storage.Workflows
 			try {
 				await transaction.rollback();
 			} catch {}
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MSSQL", "UPDATE_WORKFLOW_RESULTS", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -4596,14 +4847,16 @@ var WorkflowsMSSQL = class WorkflowsMSSQL extends _mastra_core_storage.Workflows
 			}, error);
 		}
 	}
-	async updateWorkflowState({ workflowName, runId, opts }) {
+	async updateWorkflowState({ workflowName, runId, opts, fence: explicitFence }) {
 		const table = getTableName({
 			indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 			schemaName: getSchemaName(this.schema)
 		});
+		const fence = (0, _mastra_core_storage.resolveRunFence)(this, explicitFence, runId);
 		const transaction = this.pool.transaction();
 		try {
 			await transaction.begin();
+			if (fence) await assertRunFence(transaction, this.#runOwnersTable, fence, "updateWorkflowState");
 			const selectRequest = new mssql.default.Request(transaction);
 			selectRequest.input("workflow_name", workflowName);
 			selectRequest.input("run_id", runId);
@@ -4659,31 +4912,34 @@ var WorkflowsMSSQL = class WorkflowsMSSQL extends _mastra_core_storage.Workflows
 			}, error);
 		}
 	}
-	async persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot }) {
+	async persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot, fence }) {
 		const table = getTableName({
 			indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 			schemaName: getSchemaName(this.schema)
 		});
 		const now = (/* @__PURE__ */ new Date()).toISOString();
 		try {
-			const request = this.pool.request();
-			request.input("workflow_name", workflowName);
-			request.input("run_id", runId);
-			request.input("resourceId", resourceId);
-			request.input("snapshot", JSON.stringify(snapshot));
-			request.input("createdAt", mssql.default.DateTime2, new Date(now));
-			request.input("updatedAt", mssql.default.DateTime2, new Date(now));
-			const mergeSql = `MERGE INTO ${table} AS target
-        USING (SELECT @workflow_name AS workflow_name, @run_id AS run_id) AS src
-        ON target.workflow_name = src.workflow_name AND target.run_id = src.run_id
-        WHEN MATCHED THEN UPDATE SET
-          resourceId = @resourceId,
-          snapshot = @snapshot,
-          [updatedAt] = @updatedAt
-        WHEN NOT MATCHED THEN INSERT (workflow_name, run_id, resourceId, snapshot, [createdAt], [updatedAt])
-          VALUES (@workflow_name, @run_id, @resourceId, @snapshot, @createdAt, @updatedAt);`;
-			await request.query(mergeSql);
+			await withRunFence(this.pool, this.#runOwnersTable, (0, _mastra_core_storage.resolveRunFence)(this, fence, runId), "persistWorkflowSnapshot", async (q) => {
+				const request = q.request();
+				request.input("workflow_name", workflowName);
+				request.input("run_id", runId);
+				request.input("resourceId", resourceId);
+				request.input("snapshot", JSON.stringify(snapshot));
+				request.input("createdAt", mssql.default.DateTime2, new Date(now));
+				request.input("updatedAt", mssql.default.DateTime2, new Date(now));
+				const mergeSql = `MERGE INTO ${table} AS target
+            USING (SELECT @workflow_name AS workflow_name, @run_id AS run_id) AS src
+            ON target.workflow_name = src.workflow_name AND target.run_id = src.run_id
+            WHEN MATCHED THEN UPDATE SET
+              resourceId = @resourceId,
+              snapshot = @snapshot,
+              [updatedAt] = @updatedAt
+            WHEN NOT MATCHED THEN INSERT (workflow_name, run_id, resourceId, snapshot, [createdAt], [updatedAt])
+              VALUES (@workflow_name, @run_id, @resourceId, @snapshot, @createdAt, @updatedAt);`;
+				await request.query(mergeSql);
+			});
 		} catch (error) {
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MSSQL", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,
@@ -4752,23 +5008,15 @@ var WorkflowsMSSQL = class WorkflowsMSSQL extends _mastra_core_storage.Workflows
 			}, error);
 		}
 	}
-	async deleteWorkflowRunById({ runId, workflowName }) {
+	async deleteWorkflowRunById({ runId, workflowName, fence }) {
 		const table = getTableName({
 			indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
 			schemaName: getSchemaName(this.schema)
 		});
-		const transaction = this.pool.transaction();
 		try {
-			await transaction.begin();
-			const deleteRequest = new mssql.default.Request(transaction);
-			deleteRequest.input("workflow_name", workflowName);
-			deleteRequest.input("run_id", runId);
-			await deleteRequest.query(`DELETE FROM ${table} WHERE workflow_name = @workflow_name AND run_id = @run_id`);
-			await transaction.commit();
+			await withRunFence(this.pool, this.#runOwnersTable, (0, _mastra_core_storage.resolveRunFence)(this, fence, runId), "deleteWorkflowRunById", (q) => q.request().input("workflow_name", workflowName).input("run_id", runId).query(`DELETE FROM ${table} WHERE workflow_name = @workflow_name AND run_id = @run_id`));
 		} catch (error) {
-			try {
-				await transaction.rollback();
-			} catch {}
+			if ((0, _mastra_core_storage.isRunFenceConflictError)(error)) throw error;
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("MSSQL", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
 				domain: _mastra_core_error.ErrorDomain.STORAGE,