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

package/dist/index.js

@@ -1849,6 +1849,9 @@ MIGRATION REQUIRED: Duplicate spans detected in ${TABLE_SPANS}\n================
 					this.logger.debug(`LibSQLDB: Created unique index on (spanId, traceId) for ${TABLE_SPANS}`);
 				}
 			}
+			await this.client.execute(`CREATE INDEX IF NOT EXISTS "mastra_ai_spans_roots_started_at_idx" ON "${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 "${TABLE_SPANS}" ("traceId", "startedAt")`);
+			this.logger.debug(`LibSQLDB: Ensured trace read indexes for ${TABLE_SPANS}`);
 			this.logger.info(`LibSQLDB: Migration completed for ${TABLE_SPANS}`);
 		} catch (error) {
 			if (error instanceof MastraError) throw error;
@@ -3020,8 +3023,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;
@@ -8606,6 +8616,71 @@ var MemoryLibSQL = class MemoryLibSQL extends 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 "${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 "${TABLE_THREADS}" SET "resourceId" = ?, "updatedAt" = ? WHERE id = ?`,
+					args: [
+						resourceId,
+						now.toISOString(),
+						threadId
+					]
+				});
+				await tx.execute({
+					sql: `UPDATE "${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 MastraError({
+				id: createStorageErrorId("LIBSQL", "UPDATE_THREAD_RESOURCE_ID", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					threadId,
+					resourceId
+				}
+			}, error);
+		}
+	}
 	async listThreads(args) {
 		const { page = 0, perPage: perPageInput, orderBy, filter } = args;
 		try {
@@ -8794,7 +8869,7 @@ var MemoryLibSQL = class MemoryLibSQL extends 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 MastraError({
@@ -8812,9 +8887,8 @@ var MemoryLibSQL = class MemoryLibSQL extends 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 "${TABLE_MESSAGES}" WHERE thread_id = ?`;
 			const messageParams = [sourceThreadId];
 			if (options?.messageFilter?.startDate) {
@@ -8872,68 +8946,28 @@ var MemoryLibSQL = class MemoryLibSQL extends 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 "${TABLE_MESSAGES}" (id, thread_id, content, role, type, "createdAt", "resourceId")
-                    SELECT ?, ?, content, role, type, "createdAt", ?
-                    FROM "${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 "${TABLE_MESSAGES}" (id, thread_id, content, role, type, "createdAt", "resourceId")
-                  VALUES (?, ?, ?, ?, ?, ?, ?)`,
+                  SELECT ?, ?, content, role, type, "createdAt", ?
+                  FROM "${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) {
@@ -9903,6 +9937,8 @@ var MemoryLibSQL = class MemoryLibSQL extends MemoryStorage {
 };
 //#endregion
 //#region src/storage/domains/notifications/index.ts
+/** Ids per UPDATE statement — keeps bind parameters well under SQLite's per-statement limit. */
+const BULK_ID_BATCH_SIZE = 500;
 const statusTimestamp = (status, now) => {
 	if (status === "delivered") return { deliveredAt: now };
 	if (status === "seen") return { seenAt: now };
@@ -10203,6 +10239,31 @@ var NotificationsLibSQL = class NotificationsLibSQL extends NotificationsStorage
 		if (!updated) throw new Error(`Notification ${input.id} was not found for thread ${input.threadId}`);
 		return updated;
 	}
+	async updateNotificationsStatus(input) {
+		const ids = Array.from(new Set(input.ids));
+		if (ids.length === 0) return [];
+		const now = /* @__PURE__ */ new Date();
+		const assignments = {
+			status: input.status,
+			updatedAt: now.toISOString()
+		};
+		for (const [column, value] of Object.entries(statusTimestamp(input.status, now))) assignments[column] = value.toISOString();
+		const setClause = Object.keys(assignments).map((column) => `"${column}" = ?`).join(", ");
+		const updated = [];
+		for (let offset = 0; offset < ids.length; offset += BULK_ID_BATCH_SIZE) {
+			const batch = ids.slice(offset, offset + BULK_ID_BATCH_SIZE);
+			const result = await this.#db.executeWriteOperationWithRetry(() => withClientWriteLock(this.#client, () => this.#client.execute({
+				sql: `UPDATE "${TABLE_NOTIFICATIONS}" SET ${setClause} WHERE "threadId" = ? AND "id" IN (${batch.map(() => "?").join(", ")}) RETURNING ${buildSelectColumns(TABLE_NOTIFICATIONS)}`,
+				args: [
+					...Object.values(assignments),
+					input.threadId,
+					...batch
+				]
+			})), `bulk update notification status in table ${TABLE_NOTIFICATIONS}`);
+			for (const row of result.rows ?? []) updated.push(rowToNotification(row));
+		}
+		return updated;
+	}
 	async findCoalescable(input) {
 		if (!input.dedupeKey && !input.coalesceKey) return void 0;
 		const agentId = input.agentId ?? null;