@mastra/libsql 1.22.6-alpha.0 → 1.23.0-alpha.2

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.22.6-alpha.0"
+  version: "1.23.0-alpha.2"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

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

package/dist/docs/references/docs-memory-message-history.md

@@ -122,6 +122,8 @@ You can use this history in two ways:
 - **Automatic inclusion**: Mastra automatically includes recent messages in the context window. The default of 10 messages keeps agents grounded in the conversation. Adjust it with `lastMessages` when needed.
 - [**Manual querying**](#querying): For more control, query threads and messages directly with `recall()`. Use the results to choose which memories enter the context window or to render conversation history in your UI.
 
+> **Note:** `lastMessages` counts every stored message, including tool calls, tool results, and [signals](https://mastra.ai/docs/harness/signals) of any kind, so a single turn can add several messages to the count. The window also slides forward on every request: once a thread grows past the limit, the oldest message leaves context on each turn, which changes the start of the prompt and invalidates the provider prompt cache. For long-running conversations, use [Observational Memory](https://mastra.ai/docs/memory/observational-memory), which keeps the prompt prefix stable.
+
 > **Tip:** When memory is enabled, [Studio](https://mastra.ai/docs/studio/overview) uses message history to display past conversations in the chat sidebar.
 
 ## Thread title generation
@@ -343,7 +345,9 @@ const { thread, clonedMessages } = await memory.cloneThread({
 
 You can filter cloned messages by count or date range and specify custom thread IDs. Utility methods are also available to inspect clone relationships.
 
-See [`cloneThread()`](https://mastra.ai/reference/memory/cloneThread) and [clone utilities](https://mastra.ai/reference/memory/clone-utilities) for the full API.
+If you don't need the copied messages returned, for example when forking a long thread, use `copyThread()`. It never returns message payloads, and on LibSQL and PostgreSQL the rows are copied inside the database. When semantic recall is enabled, the copied messages are still read back in batches to generate embeddings.
+
+See [`cloneThread()`](https://mastra.ai/reference/memory/cloneThread), [`copyThread()`](https://mastra.ai/reference/memory/copyThread), and [clone utilities](https://mastra.ai/reference/memory/clone-utilities) for the full API.
 
 ## Deleting messages
 

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

@@ -39,7 +39,7 @@ export const agent = new Agent({
 
 **options** (`MemoryConfig`): Memory configuration options.
 
-**options.lastMessages** (`number | false`): Number of most recent messages to include in context. Set to false to disable the message history feature entirely (messages are not loaded into context or saved). Use Number.MAX\_SAFE\_INTEGER to retrieve all messages with no limit. To load messages without saving new ones, use the readOnly option.
+**options.lastMessages** (`number | false`): Number of most recent messages to include in context. Set to false to disable the message history feature entirely (messages are not loaded into context or saved). Use Number.MAX\_SAFE\_INTEGER to retrieve all messages with no limit. To load messages without saving new ones, use the readOnly option. The window slides forward on every request, so once a thread exceeds the limit, each turn invalidates the provider prompt cache. For long-running conversations, use Observational Memory instead.
 
 **options.readOnly** (`boolean`): When true, prevents memory from saving new messages and provides working memory as read-only context (without the updateWorkingMemory tool). Useful for read-only operations like previews, internal routing agents, or sub agents that should reference but not modify memory.
 
@@ -147,5 +147,6 @@ export const agent = new Agent({
 - [listThreads](https://mastra.ai/reference/memory/listThreads)
 - [deleteMessages](https://mastra.ai/reference/memory/deleteMessages)
 - [cloneThread](https://mastra.ai/reference/memory/cloneThread)
+- [copyThread](https://mastra.ai/reference/memory/copyThread)
 - [settled](https://mastra.ai/reference/memory/settled)
 - [Clone Utility Methods](https://mastra.ai/reference/memory/clone-utilities)

package/dist/index.cjs

@@ -1850,6 +1850,9 @@ MIGRATION REQUIRED: Duplicate spans detected in ${_mastra_core_storage.TABLE_SPA
 					this.logger.debug(`LibSQLDB: Created unique index on (spanId, traceId) for ${_mastra_core_storage.TABLE_SPANS}`);
 				}
 			}
+			await this.client.execute(`CREATE INDEX IF NOT EXISTS "mastra_ai_spans_roots_started_at_idx" ON "${_mastra_core_storage.TABLE_SPANS}" ("startedAt" DESC) WHERE "parentSpanId" IS NULL`);
+			await this.client.execute(`CREATE INDEX IF NOT EXISTS "mastra_ai_spans_trace_started_at_idx" ON "${_mastra_core_storage.TABLE_SPANS}" ("traceId", "startedAt")`);
+			this.logger.debug(`LibSQLDB: Ensured trace read indexes for ${_mastra_core_storage.TABLE_SPANS}`);
 			this.logger.info(`LibSQLDB: Migration completed for ${_mastra_core_storage.TABLE_SPANS}`);
 		} catch (error) {
 			if (error instanceof _mastra_core_error.MastraError) throw error;
@@ -3021,8 +3024,15 @@ function resolveTargets({ policies, descriptor, order }) {
 //#endregion
 //#region src/storage/domains/background-tasks/index.ts
 function serializeJson(v) {
-	if (typeof v === "object" && v != null) return JSON.stringify(v);
-	return v ?? null;
+	if (v === void 0) return null;
+	let serialized;
+	try {
+		serialized = JSON.stringify(v);
+	} catch (error) {
+		throw new Error("Failed to serialize background task value as JSON", { cause: error });
+	}
+	if (serialized === void 0) throw new Error("Failed to serialize background task value as JSON");
+	return serialized;
 }
 function parseJson$4(val) {
 	if (val == null) return void 0;
@@ -8607,6 +8617,71 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			}, error);
 		}
 	}
+	/**
+	* Atomically reassign a thread and all of its messages to a different resource.
+	*
+	* Runs inside a single write transaction. SQLite serializes write transactions, so overlapping
+	* transfers of the same thread cannot interleave the thread update with the message update:
+	* either both the thread and every message move to the new resource, or neither does. The
+	* thread's `createdAt` is preserved. Callers are responsible for authorizing the reassignment.
+	*/
+	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) {
+					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,
+					resourceId,
+					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"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					threadId,
+					resourceId
+				}
+			}, error);
+		}
+	}
 	async listThreads(args) {
 		const { page = 0, perPage: perPageInput, orderBy, filter } = args;
 		try {
@@ -8795,7 +8870,7 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			}, error);
 		}
 	}
-	async cloneThread(args) {
+	async copyThread(args) {
 		const { sourceThreadId, newThreadId: providedThreadId, resourceId, title, metadata, options } = args;
 		const sourceThread = await this.getThreadById({ threadId: sourceThreadId });
 		if (!sourceThread) throw new _mastra_core_error.MastraError({
@@ -8813,9 +8888,8 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 			text: `Thread with id ${newThreadId} already exists`,
 			details: { newThreadId }
 		});
-		const hydrateMessages = options?.hydrateMessages ?? true;
 		try {
-			let messageQuery = `SELECT ${hydrateMessages ? `id, content, role, type, "createdAt", thread_id, "resourceId"` : `id, "createdAt"`}
+			let messageQuery = `SELECT id, "createdAt"
                           FROM "${_mastra_core_storage.TABLE_MESSAGES}" WHERE thread_id = ?`;
 			const messageParams = [sourceThreadId];
 			if (options?.messageFilter?.startDate) {
@@ -8873,68 +8947,28 @@ var MemoryLibSQL = class MemoryLibSQL extends _mastra_core_storage.MemoryStorage
 						nowStr
 					]
 				});
-				const clonedMessages = [];
 				const messageIdMap = {};
 				const targetResourceId = resourceId || sourceThread.resourceId;
 				for (const sourceMsg of sourceMessages) {
 					const newMessageId = crypto.randomUUID();
 					const sourceMsgId = sourceMsg.id;
 					messageIdMap[sourceMsgId] = newMessageId;
-					if (!hydrateMessages) {
-						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 clone message ${sourceMsgId}: expected 1 row copied but got ${insertResult.rowsAffected}`);
-						continue;
-					}
-					const contentStr = sourceMsg.content;
-					let parsedContent;
-					try {
-						parsedContent = JSON.parse(contentStr);
-					} catch {
-						parsedContent = {
-							format: 2,
-							parts: [{
-								type: "text",
-								text: contentStr
-							}]
-						};
-					}
-					await tx.execute({
+					const insertResult = await tx.execute({
 						sql: `INSERT INTO "${_mastra_core_storage.TABLE_MESSAGES}" (id, thread_id, content, role, type, "createdAt", "resourceId")
-                  VALUES (?, ?, ?, ?, ?, ?, ?)`,
+                  SELECT ?, ?, content, role, type, "createdAt", ?
+                  FROM "${_mastra_core_storage.TABLE_MESSAGES}" WHERE id = ?`,
 						args: [
 							newMessageId,
 							newThreadId,
-							contentStr,
-							sourceMsg.role,
-							sourceMsg.type || "v2",
-							sourceMsg.createdAt,
-							targetResourceId
+							targetResourceId,
+							sourceMsgId
 						]
 					});
-					clonedMessages.push({
-						id: newMessageId,
-						threadId: newThreadId,
-						content: parsedContent,
-						role: sourceMsg.role,
-						type: sourceMsg.type || void 0,
-						createdAt: new Date(sourceMsg.createdAt),
-						resourceId: targetResourceId
-					});
+					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,
-					clonedMessages,
 					messageIdMap
 				};
 			} catch (error) {