@mastra/libsql 1.25.1 → 1.25.2-alpha.0

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-libsql
 description: Documentation for @mastra/libsql. Use when working with @mastra/libsql APIs, configuration, or implementation.
 metadata:
   package: "@mastra/libsql"
-  version: "1.25.1"
+  version: "1.25.2-alpha.0"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.25.1",
+  "version": "1.25.2-alpha.0",
   "package": "@mastra/libsql",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-agents-human-in-the-loop.md

@@ -125,7 +125,7 @@ import { agent } from './agent'
 
 const approvalClassifier = new Classifier({
   id: 'tool-approval-classifier',
-  model: typeSafeAi.evaluationModel('jev-latest'),
+  model: typeSafeAi.decisionModel('jev-latest'),
   questions: {
     requiresApproval: {
       type: 'boolean',
@@ -137,7 +137,7 @@ const approvalClassifier = new Classifier({
 
 const stream = await agent.stream('Clean up old records', {
   requireToolApproval: async ({ toolName, args }) => {
-    const result = await approvalClassifier.evaluate({
+    const result = await approvalClassifier.decide({
       state: {
         toolName,
         argumentNames: Object.keys(args),
@@ -149,7 +149,7 @@ const stream = await agent.stream('Clean up old records', {
 })
 ```
 
-The example sends argument names rather than values because the classifier forwards its state to the configured evaluation model. If the decision requires argument values, redact sensitive data first or use an evaluation model and provider that meet the protected tool's data-handling requirements.
+The example sends argument names rather than values because the classifier forwards its state to the configured decision model. If the decision requires argument values, redact sensitive data first or use a decision model and provider that meet the protected tool's data-handling requirements.
 
 Returning `true` pauses the tool call for human approval. It doesn't approve or decline the call automatically. Choose a threshold that matches the risk of the tools available to the agent. If this `requireToolApproval` function throws, it defaults to requiring approval.
 
@@ -260,6 +260,8 @@ const weatherTool = createTool({
 
 > **Note:** `suspend()` doesn't throw, return immediately after calling it (e.g. `return await suspend({ ... })`). Code after `await suspend(...)` still runs before the tool pauses.
 
+Use `suspend()` instead of a tool without `execute` when the tool needs a structured answer from the user and also runs inside a subagent: subagents can't run client tools, but suspension propagates through the supervisor. To resume from AI SDK `useChat()`, see [resuming a suspended tool from `useChat()`](https://mastra.ai/integrations/agentic-ui/ai-sdk-ui).
+
 ## Tool approval with `generate()`
 
 Tool approval also works with `generate()` for non-streaming use cases. When a tool requires approval, `generate()` returns immediately with `finishReason: 'suspended'`, a `suspendPayload` containing the tool call details (`toolCallId`, `toolName`, `args`), and a `runId`:

package/dist/docs/references/docs-memory-memory-processors.md

@@ -99,7 +99,7 @@ import { Agent } from '@mastra/core/agent'
 import { Memory } from '@mastra/memory'
 import { LibSQLStore } from '@mastra/libsql'
 import { PineconeVector } from '@mastra/pinecone'
-import { OpenAIEmbedder } from '@mastra/openai'
+import { ModelRouterEmbeddingModel } from '@mastra/core/llm'
 import { openai } from '@ai-sdk/openai'
 
 const agent = new Agent({
@@ -115,10 +115,7 @@ const agent = new Agent({
       id: 'memory-vector',
       apiKey: process.env.PINECONE_API_KEY!,
     }),
-    embedder: new OpenAIEmbedder({
-      model: 'text-embedding-3-small',
-      apiKey: process.env.OPENAI_API_KEY!,
-    }),
+    embedder: new ModelRouterEmbeddingModel('openai/text-embedding-3-small'),
     semanticRecall: { enabled: true }, // SemanticRecall processor automatically added
   }),
 })

package/dist/docs/references/docs-memory-semantic-recall.md

@@ -411,11 +411,11 @@ PostgreSQL supports both IVFFlat and HNSW indexes. By default, Mastra creates an
 
 ```typescript
 import { Memory } from '@mastra/memory'
-import { PgStore, PgVector } from '@mastra/pg'
+import { PostgresStore, PgVector } from '@mastra/pg'
 
 const agent = new Agent({
   memory: new Memory({
-    storage: new PgStore({
+    storage: new PostgresStore({
       id: 'agent-storage',
       connectionString: process.env.DATABASE_URL,
     }),

package/dist/docs/references/docs-memory-working-memory.md

@@ -272,6 +272,22 @@ Schema-based working memory uses **merge semantics**, meaning the agent only nee
 - **Set a field to `null` to delete it:** This explicitly removes the field from memory
 - **Arrays are replaced entirely:** When an array field is provided, it replaces the existing array (arrays aren't merged element-by-element)
 
+### Concurrent updates
+
+With `scope: 'resource'` and a storage adapter that supports atomic merges (currently `@mastra/pg`), each merge runs inside a row-locked database transaction. Concurrent updates to different fields from separate processes are all kept. Other adapters merge in the application, which only serializes writers inside a single process.
+
+To merge a partial update from your own code, call `memory.mergeWorkingMemory()`:
+
+```typescript
+await memory.mergeWorkingMemory({
+  threadId: 'thread-1',
+  resourceId: 'user-123',
+  workingMemory: { preferences: { tone: 'formal' } },
+})
+```
+
+It throws if working memory isn't schema-based and resource-scoped, or if the storage adapter doesn't support atomic merges. Check `await memory.supportsAtomicWorkingMemoryMerge()` first if you need to fall back.
+
 ## Choosing between template and schema
 
 - Use a **template** (Markdown) if you want the agent to maintain memory as a free-form text block, such as a user profile or scratchpad. Templates use **replace semantics**: the agent must provide the complete memory content on each update.

package/dist/docs/references/reference-memory-memory-class.md

@@ -101,14 +101,14 @@ export const agent = new Agent({
 import { Memory } from '@mastra/memory'
 import { Agent } from '@mastra/core/agent'
 import { ModelRouterEmbeddingModel } from '@mastra/core/llm'
-import { PgStore, PgVector } from '@mastra/pg'
+import { PostgresStore, PgVector } from '@mastra/pg'
 
 export const agent = new Agent({
   name: 'pg-agent',
   instructions: 'You are an agent with optimized PostgreSQL memory.',
   model: 'openai/gpt-5.6-sol',
   memory: new Memory({
-    storage: new PgStore({
+    storage: new PostgresStore({
       id: 'pg-agent-storage',
       connectionString: process.env.DATABASE_URL,
     }),

package/dist/index.cjs

@@ -7862,6 +7862,14 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			initialBackoffMs: config.initialBackoffMs
 		});
 	}
+	/**
+	* Runs a write behind the per-client write lock and retries it on transient SQLite lock
+	* errors (`SQLITE_BUSY`), like the shared `LibSQLDB` writes. Each retry re-queues on the lock.
+	* `fn` must be safe to rerun: a single statement, a batch, or a transaction that rolls back.
+	*/
+	#write(operation, fn) {
+		return this.#db.executeWriteOperationWithRetry(() => withClientWriteLock(this.#client, fn), operation);
+	}
 	async init() {
 		await this.#db.createTable({
 			tableName: _mastra_core_storage.TABLE_THREADS,
@@ -8363,9 +8371,9 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			const threadUpdateStatement = batchStatements[batchStatements.length - 1];
 			for (let i = 0; i < messageStatements.length; i += BATCH_SIZE) {
 				const batch = messageStatements.slice(i, i + BATCH_SIZE);
-				if (batch.length > 0) await this.#client.batch(batch, "write");
+				if (batch.length > 0) await this.#write("saveMessages", () => this.#client.batch(batch, "write"));
 			}
-			if (threadUpdateStatement) await this.#client.execute(threadUpdateStatement);
+			if (threadUpdateStatement) await this.#write("saveMessages", () => this.#client.execute(threadUpdateStatement));
 			return { messages: new _mastra_core_agent.MessageList().add(messages, "memory").get.all.db() };
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
@@ -8431,7 +8439,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			sql: `UPDATE ${_mastra_core_storage.TABLE_THREADS} SET updatedAt = ? WHERE id = ?`,
 			args: [now, threadId]
 		});
-		await this.#client.batch(batchStatements, "write");
+		await this.#write("updateMessages", () => this.#client.batch(batchStatements, "write"));
 		return (await this.#client.execute({
 			sql: selectSql,
 			args: messageIds
@@ -8441,35 +8449,37 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 		if (!messageIds || messageIds.length === 0) return;
 		try {
 			const BATCH_SIZE = 100;
-			const threadIds = /* @__PURE__ */ new Set();
-			const tx = await this.#client.transaction("write");
-			try {
-				for (let i = 0; i < messageIds.length; i += BATCH_SIZE) {
-					const batch = messageIds.slice(i, i + BATCH_SIZE);
-					const placeholders = batch.map(() => "?").join(",");
-					(await tx.execute({
-						sql: `SELECT DISTINCT thread_id FROM "${_mastra_core_storage.TABLE_MESSAGES}" WHERE id IN (${placeholders})`,
-						args: batch
-					})).rows?.forEach((row) => {
-						if (row.thread_id) threadIds.add(row.thread_id);
-					});
-					await tx.execute({
-						sql: `DELETE FROM "${_mastra_core_storage.TABLE_MESSAGES}" WHERE id IN (${placeholders})`,
-						args: batch
-					});
-				}
-				if (threadIds.size > 0) {
-					const now = (/* @__PURE__ */ new Date()).toISOString();
-					for (const threadId of threadIds) await tx.execute({
-						sql: `UPDATE "${_mastra_core_storage.TABLE_THREADS}" SET "updatedAt" = ? WHERE id = ?`,
-						args: [now, threadId]
-					});
+			await this.#write("deleteMessages", async () => {
+				const threadIds = /* @__PURE__ */ new Set();
+				const tx = await this.#client.transaction("write");
+				try {
+					for (let i = 0; i < messageIds.length; i += BATCH_SIZE) {
+						const batch = messageIds.slice(i, i + BATCH_SIZE);
+						const placeholders = batch.map(() => "?").join(",");
+						(await tx.execute({
+							sql: `SELECT DISTINCT thread_id FROM "${_mastra_core_storage.TABLE_MESSAGES}" WHERE id IN (${placeholders})`,
+							args: batch
+						})).rows?.forEach((row) => {
+							if (row.thread_id) threadIds.add(row.thread_id);
+						});
+						await tx.execute({
+							sql: `DELETE FROM "${_mastra_core_storage.TABLE_MESSAGES}" WHERE id IN (${placeholders})`,
+							args: batch
+						});
+					}
+					if (threadIds.size > 0) {
+						const now = (/* @__PURE__ */ new Date()).toISOString();
+						for (const threadId of threadIds) await tx.execute({
+							sql: `UPDATE "${_mastra_core_storage.TABLE_THREADS}" SET "updatedAt" = ? WHERE id = ?`,
+							args: [now, threadId]
+						});
+					}
+					await tx.commit();
+				} catch (error) {
+					await tx.rollback();
+					throw error;
 				}
-				await tx.commit();
-			} catch (error) {
-				await tx.rollback();
-				throw error;
-			}
+			});
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", "DELETE_MESSAGES", "FAILED"),
@@ -8534,10 +8544,10 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 		updates.push("updatedAt = ?");
 		values.push(updatedResource.updatedAt.toISOString());
 		values.push(resourceId);
-		await this.#client.execute({
+		await this.#write("updateResource", () => this.#client.execute({
 			sql: `UPDATE ${_mastra_core_storage.TABLE_RESOURCES} SET ${updates.join(", ")} WHERE id = ?`,
 			args: values
-		});
+		}));
 		return updatedResource;
 	}
 	async getThreadById({ threadId, resourceId }) {
@@ -8574,49 +8584,51 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	*/
 	async updateThreadResourceId({ threadId, resourceId }) {
 		try {
-			const tx = await this.#client.transaction("write");
-			try {
-				const row = (await tx.execute({
-					sql: `SELECT * FROM "${_mastra_core_storage.TABLE_THREADS}" WHERE id = ?`,
-					args: [threadId]
-				})).rows?.[0];
-				if (!row) throw new Error(`Thread "${threadId}" not found`);
-				const currentResourceId = row.resourceId;
-				const normalized = {
-					id: row.id,
-					resourceId: currentResourceId,
-					title: row.title,
-					metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata,
-					createdAt: new Date(row.createdAt),
-					updatedAt: new Date(row.updatedAt)
-				};
-				if (currentResourceId === resourceId) {
+			return await this.#write("updateThreadResourceId", async () => {
+				const tx = await this.#client.transaction("write");
+				try {
+					const row = (await tx.execute({
+						sql: `SELECT * FROM "${_mastra_core_storage.TABLE_THREADS}" WHERE id = ?`,
+						args: [threadId]
+					})).rows?.[0];
+					if (!row) throw new Error(`Thread "${threadId}" not found`);
+					const currentResourceId = row.resourceId;
+					const normalized = {
+						id: row.id,
+						resourceId: currentResourceId,
+						title: row.title,
+						metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata,
+						createdAt: new Date(row.createdAt),
+						updatedAt: new Date(row.updatedAt)
+					};
+					if (currentResourceId === resourceId) {
+						await tx.commit();
+						return normalized;
+					}
+					const now = /* @__PURE__ */ new Date();
+					await tx.execute({
+						sql: `UPDATE "${_mastra_core_storage.TABLE_THREADS}" SET "resourceId" = ?, "updatedAt" = ? WHERE id = ?`,
+						args: [
+							resourceId,
+							now.toISOString(),
+							threadId
+						]
+					});
+					await tx.execute({
+						sql: `UPDATE "${_mastra_core_storage.TABLE_MESSAGES}" SET "resourceId" = ? WHERE thread_id = ?`,
+						args: [resourceId, threadId]
+					});
 					await tx.commit();
-					return normalized;
-				}
-				const now = /* @__PURE__ */ new Date();
-				await tx.execute({
-					sql: `UPDATE "${_mastra_core_storage.TABLE_THREADS}" SET "resourceId" = ?, "updatedAt" = ? WHERE id = ?`,
-					args: [
+					return {
+						...normalized,
 						resourceId,
-						now.toISOString(),
-						threadId
-					]
-				});
-				await tx.execute({
-					sql: `UPDATE "${_mastra_core_storage.TABLE_MESSAGES}" SET "resourceId" = ? WHERE thread_id = ?`,
-					args: [resourceId, threadId]
-				});
-				await tx.commit();
-				return {
-					...normalized,
-					resourceId,
-					updatedAt: now
-				};
-			} catch (error) {
-				await tx.rollback();
-				throw error;
-			}
+						updatedAt: now
+					};
+				} catch (error) {
+					await tx.rollback();
+					throw error;
+				}
+			});
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", "UPDATE_THREAD_RESOURCE_ID", "FAILED"),
@@ -8778,7 +8790,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			updatedAt: now
 		};
 		try {
-			await this.#client.execute({
+			await this.#write("updateThread", () => this.#client.execute({
 				sql: `UPDATE ${_mastra_core_storage.TABLE_THREADS} SET title = COALESCE(?, title), metadata = jsonb(?), updatedAt = ? WHERE id = ?`,
 				args: [
 					title ?? null,
@@ -8786,7 +8798,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 					now.toISOString(),
 					id
 				]
-			});
+			}));
 			return updatedThread;
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
@@ -8800,14 +8812,14 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async deleteThread({ threadId }) {
 		try {
-			await this.#client.execute({
+			await this.#write("deleteThread", () => this.#client.execute({
 				sql: `DELETE FROM ${_mastra_core_storage.TABLE_MESSAGES} WHERE thread_id = ?`,
 				args: [threadId]
-			});
-			await this.#client.execute({
+			}));
+			await this.#write("deleteThread", () => this.#client.execute({
 				sql: `DELETE FROM ${_mastra_core_storage.TABLE_THREADS} WHERE id = ?`,
 				args: [threadId]
-			});
+			}));
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("LIBSQL", "DELETE_THREAD", "FAILED"),
@@ -8880,48 +8892,50 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 				createdAt: now,
 				updatedAt: now
 			};
-			const tx = await this.#client.transaction("write");
-			try {
-				await tx.execute({
-					sql: `INSERT INTO "${_mastra_core_storage.TABLE_THREADS}" (id, "resourceId", title, metadata, "createdAt", "updatedAt")
-                VALUES (?, ?, ?, jsonb(?), ?, ?)`,
-					args: [
-						newThread.id,
-						newThread.resourceId,
-						newThread.title ?? "",
-						JSON.stringify(newThread.metadata),
-						nowStr,
-						nowStr
-					]
-				});
-				const messageIdMap = {};
-				const targetResourceId = resourceId || sourceThread.resourceId;
-				for (const sourceMsg of sourceMessages) {
-					const newMessageId = crypto.randomUUID();
-					const sourceMsgId = sourceMsg.id;
-					messageIdMap[sourceMsgId] = newMessageId;
-					const insertResult = await tx.execute({
-						sql: `INSERT INTO "${_mastra_core_storage.TABLE_MESSAGES}" (id, thread_id, content, role, type, "createdAt", "resourceId")
-                  SELECT ?, ?, content, role, type, "createdAt", ?
-                  FROM "${_mastra_core_storage.TABLE_MESSAGES}" WHERE id = ?`,
+			return await this.#write("copyThread", async () => {
+				const tx = await this.#client.transaction("write");
+				try {
+					await tx.execute({
+						sql: `INSERT INTO "${_mastra_core_storage.TABLE_THREADS}" (id, "resourceId", title, metadata, "createdAt", "updatedAt")
+                  VALUES (?, ?, ?, jsonb(?), ?, ?)`,
 						args: [
-							newMessageId,
-							newThreadId,
-							targetResourceId,
-							sourceMsgId
+							newThread.id,
+							newThread.resourceId,
+							newThread.title ?? "",
+							JSON.stringify(newThread.metadata),
+							nowStr,
+							nowStr
 						]
 					});
-					if (insertResult.rowsAffected !== 1) throw new Error(`Failed to copy message ${sourceMsgId}: expected 1 row copied but got ${insertResult.rowsAffected}`);
+					const messageIdMap = {};
+					const targetResourceId = resourceId || sourceThread.resourceId;
+					for (const sourceMsg of sourceMessages) {
+						const newMessageId = crypto.randomUUID();
+						const sourceMsgId = sourceMsg.id;
+						messageIdMap[sourceMsgId] = newMessageId;
+						const insertResult = await tx.execute({
+							sql: `INSERT INTO "${_mastra_core_storage.TABLE_MESSAGES}" (id, thread_id, content, role, type, "createdAt", "resourceId")
+                    SELECT ?, ?, content, role, type, "createdAt", ?
+                    FROM "${_mastra_core_storage.TABLE_MESSAGES}" WHERE id = ?`,
+							args: [
+								newMessageId,
+								newThreadId,
+								targetResourceId,
+								sourceMsgId
+							]
+						});
+						if (insertResult.rowsAffected !== 1) throw new Error(`Failed to copy message ${sourceMsgId}: expected 1 row copied but got ${insertResult.rowsAffected}`);
+					}
+					await tx.commit();
+					return {
+						thread: newThread,
+						messageIdMap
+					};
+				} catch (error) {
+					await tx.rollback();
+					throw error;
 				}
-				await tx.commit();
-				return {
-					thread: newThread,
-					messageIdMap
-				};
-			} catch (error) {
-				await tx.rollback();
-				throw error;
-			}
+			});
 		} catch (error) {
 			if (error instanceof _mastra_core_error.MastraError) throw error;
 			throw new _mastra_core_error.MastraError({
@@ -9081,7 +9095,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 				config: input.config,
 				observedTimezone: input.observedTimezone
 			};
-			await withClientWriteLock(this.#client, () => this.#client.execute({
+			await this.#write("initializeObservationalMemory", () => this.#client.execute({
 				sql: `INSERT INTO "${OM_TABLE}" (
             id, "lookupKey", scope, "resourceId", "threadId",
             "activeObservations", "activeObservationsPendingUpdate",
@@ -9133,7 +9147,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	async insertObservationalMemoryRecord(record) {
 		try {
 			const lookupKey = this.getOMKey(record.threadId, record.resourceId);
-			await withClientWriteLock(this.#client, () => this.#client.execute({
+			await this.#write("insertObservationalMemoryRecord", () => this.#client.execute({
 				sql: `INSERT INTO "${OM_TABLE}" (
             id, "lookupKey", scope, "resourceId", "threadId",
             "activeObservations", "activeObservationsPendingUpdate",
@@ -9197,7 +9211,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 		try {
 			const now = /* @__PURE__ */ new Date();
 			const observedMessageIdsJson = input.observedMessageIds ? JSON.stringify(input.observedMessageIds) : null;
-			if ((await withClientWriteLock(this.#client, () => this.#client.execute({
+			if ((await this.#write("updateActiveObservations", () => this.#client.execute({
 				sql: `UPDATE "${OM_TABLE}" SET
             "activeObservations" = ?,
             "lastObservedAt" = ?,
@@ -9235,7 +9249,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async createReflectionGeneration(input) {
 		try {
-			return await withClientWriteLock(this.#client, async () => {
+			return await this.#write("createReflectionGeneration", async () => {
 				const tx = await this.#client.transaction("write");
 				try {
 					const record = await this.#insertReflectionGeneration(tx, input);
@@ -9331,7 +9345,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async setReflectingFlag(id, isReflecting) {
 		try {
-			if ((await withClientWriteLock(this.#client, () => this.#client.execute({
+			if ((await this.#write("setReflectingFlag", () => this.#client.execute({
 				sql: `UPDATE "${OM_TABLE}" SET "isReflecting" = ?, "updatedAt" = ? WHERE id = ?`,
 				args: [
 					isReflecting,
@@ -9363,7 +9377,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async setObservingFlag(id, isObserving) {
 		try {
-			if ((await withClientWriteLock(this.#client, () => this.#client.execute({
+			if ((await this.#write("setObservingFlag", () => this.#client.execute({
 				sql: `UPDATE "${OM_TABLE}" SET "isObserving" = ?, "updatedAt" = ? WHERE id = ?`,
 				args: [
 					isObserving,
@@ -9414,7 +9428,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 					id
 				];
 			}
-			if ((await withClientWriteLock(this.#client, () => this.#client.execute({
+			if ((await this.#write("setBufferingObservationFlag", () => this.#client.execute({
 				sql,
 				args
 			}))).rowsAffected === 0) throw new _mastra_core_error.MastraError({
@@ -9444,7 +9458,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async setBufferingReflectionFlag(id, isBuffering) {
 		try {
-			if ((await withClientWriteLock(this.#client, () => this.#client.execute({
+			if ((await this.#write("setBufferingReflectionFlag", () => this.#client.execute({
 				sql: `UPDATE "${OM_TABLE}" SET "isBufferingReflection" = ?, "updatedAt" = ? WHERE id = ?`,
 				args: [
 					isBuffering,
@@ -9477,7 +9491,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	async clearObservationalMemory(threadId, resourceId) {
 		try {
 			const lookupKey = this.getOMKey(threadId, resourceId);
-			await withClientWriteLock(this.#client, () => this.#client.execute({
+			await this.#write("clearObservationalMemory", () => this.#client.execute({
 				sql: `DELETE FROM "${OM_TABLE}" WHERE "lookupKey" = ?`,
 				args: [lookupKey]
 			}));
@@ -9495,7 +9509,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async setPendingMessageTokens(id, tokenCount) {
 		try {
-			if ((await withClientWriteLock(this.#client, () => this.#client.execute({
+			if ((await this.#write("setPendingMessageTokens", () => this.#client.execute({
 				sql: `UPDATE "${OM_TABLE}" SET 
             "pendingMessageTokens" = ?, 
             "updatedAt" = ? 
@@ -9530,7 +9544,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async updateObservationalMemoryConfig(input) {
 		try {
-			await withClientWriteLock(this.#client, async () => {
+			await this.#write("updateObservationalMemoryConfig", async () => {
 				const tx = await this.#client.transaction("write");
 				try {
 					const selectResult = await tx.execute({
@@ -9574,7 +9588,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	async updateBufferedObservations(input) {
 		try {
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-			await withClientWriteLock(this.#client, async () => {
+			await this.#write("updateBufferedObservations", async () => {
 				const tx = await this.#client.transaction("write");
 				try {
 					const current = await tx.execute({
@@ -9655,7 +9669,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	async swapBufferedToActive(input) {
 		try {
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-			return await withClientWriteLock(this.#client, async () => {
+			return await this.#write("swapBufferedToActive", async () => {
 				const tx = await this.#client.transaction("write");
 				try {
 					const current = await tx.execute({
@@ -9804,7 +9818,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	async updateBufferedReflection(input) {
 		try {
 			const nowStr = (/* @__PURE__ */ new Date()).toISOString();
-			if ((await withClientWriteLock(this.#client, () => this.#client.execute({
+			if ((await this.#write("updateBufferedReflection", () => this.#client.execute({
 				sql: `UPDATE "${OM_TABLE}" SET
             "bufferedReflection" = CASE
               WHEN "bufferedReflection" IS NOT NULL AND "bufferedReflection" != ''
@@ -9844,7 +9858,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 	}
 	async swapBufferedReflectionToActive(input) {
 		try {
-			return await withClientWriteLock(this.#client, async () => {
+			return await this.#write("swapBufferedReflectionToActive", async () => {
 				const tx = await this.#client.transaction("write");
 				try {
 					const current = await tx.execute({