@mastra/pg 1.24.1-alpha.0 → 1.25.0-alpha.1

package/dist/docs/SKILL.md

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

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.24.1-alpha.0",
+  "version": "1.25.0-alpha.1",
   "package": "@mastra/pg",
   "exports": {},
   "modules": {}

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

@@ -10692,6 +10692,57 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			}, error);
 		}
 	}
+	/**
+	* Atomically reassign a thread and all of its messages to a different resource.
+	*
+	* Runs inside a single transaction and takes a `SELECT ... FOR UPDATE` row lock on the
+	* thread, so overlapping transfers of the same thread serialize and can never interleave
+	* the thread update with the message update. Either both the thread and every message move
+	* to the new resource, or neither does — there is no split-ownership window. The thread's
+	* `createdAt` is preserved. Callers are responsible for authorizing the reassignment.
+	*/
+	async updateThreadResourceId({ threadId, resourceId }) {
+		const threadsTable = getTableName$3({
+			indexName: _mastra_core_storage.TABLE_THREADS,
+			schemaName: getSchemaName$3(this.#schema)
+		});
+		const messagesTable = getTableName$3({
+			indexName: _mastra_core_storage.TABLE_MESSAGES,
+			schemaName: getSchemaName$3(this.#schema)
+		});
+		try {
+			return await this.#db.client.tx(async (t) => {
+				const thread = await t.oneOrNone(`SELECT * FROM ${threadsTable} WHERE id = $1 FOR UPDATE`, [threadId]);
+				if (!thread) throw new Error(`Thread "${threadId}" not found`);
+				const normalized = {
+					id: thread.id,
+					resourceId: thread.resourceId,
+					title: thread.title,
+					metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+					createdAt: thread.createdAtZ || thread.createdAt,
+					updatedAt: thread.updatedAtZ || thread.updatedAt
+				};
+				if (thread.resourceId === resourceId) return normalized;
+				await t.none(`UPDATE ${threadsTable} SET "resourceId" = $1, "updatedAt" = NOW(), "updatedAtZ" = NOW() WHERE id = $2`, [resourceId, threadId]);
+				await t.none(`UPDATE ${messagesTable} SET "resourceId" = $1 WHERE thread_id = $2`, [resourceId, threadId]);
+				return {
+					...normalized,
+					resourceId,
+					updatedAt: /* @__PURE__ */ new Date()
+				};
+			});
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "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 {
@@ -11696,7 +11747,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 		await this.#db.client.none(`UPDATE ${tableName} SET ${updates.join(", ")} WHERE id = $${paramIndex}`, values);
 		return updatedResource;
 	}
-	async cloneThread(args) {
+	async copyThread(args) {
 		const { sourceThreadId, newThreadId: providedThreadId, resourceId, title, metadata, options } = args;
 		const sourceThread = await this.#getThreadById(this.#db.client, { threadId: sourceThreadId });
 		if (!sourceThread) throw new _mastra_core_error.MastraError({
@@ -11722,10 +11773,9 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			indexName: _mastra_core_storage.TABLE_MESSAGES,
 			schemaName: getSchemaName$3(this.#schema)
 		});
-		const hydrateMessages = options?.hydrateMessages ?? true;
 		try {
 			return await this.#db.client.tx(async (t) => {
-				let messageQuery = `SELECT ${hydrateMessages ? `id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"` : `id, "createdAt"`}
+				let messageQuery = `SELECT id, "createdAt"
                             FROM ${messageTableName} WHERE thread_id = $1`;
 				const messageParams = [sourceThreadId];
 				let paramIndex = 2;
@@ -11786,54 +11836,23 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 					nowStr,
 					nowStr
 				]);
-				const clonedMessages = [];
 				const messageIdMap = {};
 				const targetResourceId = resourceId || sourceThread.resourceId;
 				for (const sourceMsg of sourceMessages) {
 					const newMessageId = crypto.randomUUID();
 					messageIdMap[sourceMsg.id] = newMessageId;
-					if (!hydrateMessages) {
-						const insertResult = await t.query(`INSERT INTO ${messageTableName} (id, thread_id, content, "createdAt", "createdAtZ", role, type, "resourceId")
-               SELECT $1, $2, content, "createdAt", "createdAtZ", role, type, $3
-               FROM ${messageTableName} WHERE id = $4`, [
-							newMessageId,
-							newThreadId,
-							targetResourceId,
-							sourceMsg.id
-						]);
-						if (insertResult.rowCount !== 1) throw new Error(`Failed to clone message ${sourceMsg.id}: expected 1 row copied but got ${insertResult.rowCount}`);
-						continue;
-					}
-					const normalizedMsg = this.normalizeMessageRow(sourceMsg);
-					let parsedContent = normalizedMsg.content;
-					try {
-						parsedContent = JSON.parse(normalizedMsg.content);
-					} catch {}
-					const createdAt = toUtcISOString(new Date(normalizedMsg.createdAt));
-					await t.none(`INSERT INTO ${messageTableName} (id, thread_id, content, "createdAt", "createdAtZ", role, type, "resourceId")
-             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`, [
+					const insertResult = await t.query(`INSERT INTO ${messageTableName} (id, thread_id, content, "createdAt", "createdAtZ", role, type, "resourceId")
+             SELECT $1, $2, content, "createdAt", "createdAtZ", role, type, $3
+             FROM ${messageTableName} WHERE id = $4`, [
 						newMessageId,
 						newThreadId,
-						typeof normalizedMsg.content === "string" ? normalizedMsg.content : JSON.stringify(normalizedMsg.content),
-						createdAt,
-						createdAt,
-						normalizedMsg.role,
-						normalizedMsg.type || "v2",
-						targetResourceId
+						targetResourceId,
+						sourceMsg.id
 					]);
-					clonedMessages.push({
-						id: newMessageId,
-						threadId: newThreadId,
-						content: parsedContent,
-						role: normalizedMsg.role,
-						type: normalizedMsg.type,
-						createdAt: new Date(normalizedMsg.createdAt),
-						resourceId: targetResourceId
-					});
+					if (insertResult.rowCount !== 1) throw new Error(`Failed to copy message ${sourceMsg.id}: expected 1 row copied but got ${insertResult.rowCount}`);
 				}
 				return {
 					thread: newThread,
-					clonedMessages,
 					messageIdMap
 				};
 			});