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

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.2"
 ---
 
 ## 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.2",
   "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
 				};
 			});
@@ -13188,6 +13207,27 @@ var NotificationsPG = class NotificationsPG extends _mastra_core_storage.Notific
 		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,
+			...statusTimestamp(input.status, now),
+			updatedAt: now
+		};
+		const columns = Object.keys(assignments);
+		const setClause = columns.map((column, index) => `"${(0, _mastra_core_utils.parseSqlIdentifier)(column, "column name")}" = $${index + 1}`).join(", ");
+		const tableName = getTableName$5({
+			indexName: _mastra_core_storage.TABLE_NOTIFICATIONS,
+			schemaName: getSchemaName$5(this.#schema)
+		});
+		return (await this.#db.client.manyOrNone(`UPDATE ${tableName} SET ${setClause} WHERE "threadId" = $${columns.length + 1} AND "id" = ANY($${columns.length + 2}::text[]) RETURNING *`, [
+			...Object.values(assignments),
+			input.threadId,
+			ids
+		])).map(rowToNotification);
+	}
 	async findCoalescable(input) {
 		if (!input.dedupeKey && !input.coalesceKey) return void 0;
 		const tableName = getTableName$5({
@@ -17342,6 +17382,13 @@ function collectRelationCollections(predicate, collections = /* @__PURE__ */ new
 	else if (predicate.type === "not") collectRelationCollections(predicate.arg, collections);
 	return collections;
 }
+function collectThreadRelationCollections(predicate, collections) {
+	if (!predicate) return collections;
+	if (predicate.type === "relation") collectRelationCollections(predicate.predicate, collections);
+	else if (predicate.type === "boolean") for (const arg of predicate.args) collectThreadRelationCollections(arg, collections);
+	else collectThreadRelationCollections(predicate.arg, collections);
+	return collections;
+}
 function compilePredicate(predicate, parameterOffset) {
 	if (predicate.type === "relation") {
 		const compiled = predicate.collection === "feedback" ? compileFeedbackScalarPredicate(predicate.predicate, parameterOffset) : compileScalarPredicate(predicate.predicate, predicate.collection === "spans" ? SPAN_FIELDS : SCORE_FIELDS, parameterOffset);
@@ -17376,12 +17423,41 @@ function compilePredicate(predicate, parameterOffset) {
 	}
 	return compileScalarPredicate(predicate, TRACE_FIELDS, parameterOffset, true);
 }
-function compilePostgresTraceQuery(schema, plan) {
+function compileThreadPredicate(predicate, parameterOffset) {
+	if (predicate.type === "relation") {
+		const compiled = compilePredicate(predicate.predicate, parameterOffset);
+		const existence = `EXISTS (
+      SELECT 1 FROM eligible_roots r
+      WHERE r."threadId" = t."threadId"
+        AND (${compiled.sql})
+    )`;
+		return {
+			sql: predicate.quantifier === "some" ? existence : `NOT ${existence}`,
+			values: compiled.values
+		};
+	}
+	if (predicate.type === "boolean") {
+		const values = [];
+		return {
+			sql: predicate.args.map((arg) => {
+				const compiled = compileThreadPredicate(arg, parameterOffset + values.length);
+				values.push(...compiled.values);
+				return `(${compiled.sql})`;
+			}).join(predicate.operator === "and" ? " AND " : " OR "),
+			values
+		};
+	}
+	const compiled = compileThreadPredicate(predicate.arg, parameterOffset);
+	return {
+		sql: `NOT (${compiled.sql})`,
+		values: compiled.values
+	};
+}
+function compilePostgresTraceScope(schema, selection, relationCollections) {
 	const spanTable = qualifiedTable(schema, TABLE_SPAN_EVENTS);
 	const scoreTable = qualifiedTable(schema, TABLE_SCORE_EVENTS);
 	const feedbackTable = qualifiedTable(schema, TABLE_FEEDBACK_EVENTS);
-	const values = [plan.timeRange.from, plan.timeRange.to];
-	const relationCollections = collectRelationCollections(plan.where);
+	const values = [selection.timeRange.from, selection.timeRange.to];
 	const ctes = [`root_scope AS MATERIALIZED (
     SELECT *
     FROM ${spanTable} r
@@ -17456,6 +17532,13 @@ function compilePostgresTraceQuery(schema, plan) {
       AND s."traceId" IN (SELECT "traceId" FROM root_scope)
       AND ${latestFeedbackPredicate(feedbackTable)}
   )`);
+	return {
+		ctes,
+		values
+	};
+}
+function compilePostgresTraceQuery(schema, plan) {
+	const { ctes, values } = compilePostgresTraceScope(schema, plan, collectRelationCollections(plan.where));
 	let predicateSql = "TRUE";
 	if (plan.where) {
 		const predicate = compilePredicate(plan.where, values.length + 1);
@@ -17503,6 +17586,51 @@ LIMIT $${values.length}`,
 		values
 	};
 }
+function compilePostgresThreadQuery(schema, plan) {
+	const relationCollections = collectRelationCollections(plan.traces.where);
+	collectThreadRelationCollections(plan.where, relationCollections);
+	const { ctes, values } = compilePostgresTraceScope(schema, plan.traces, relationCollections);
+	let eligibilitySql = "TRUE";
+	if (plan.traces.where) {
+		const eligibility = compilePredicate(plan.traces.where, values.length + 1);
+		eligibilitySql = eligibility.sql;
+		values.push(...eligibility.values);
+	}
+	ctes.push(`eligible_roots AS MATERIALIZED (
+    SELECT *
+    FROM root_scope r
+    WHERE ${eligibilitySql}
+  )`);
+	ctes.push(`thread_ids AS (
+    SELECT "threadId" COLLATE "C" AS "threadId"
+    FROM eligible_roots
+    WHERE "threadId" IS NOT NULL
+    GROUP BY "threadId" COLLATE "C"
+  )`);
+	let threadPredicateSql = "TRUE";
+	if (plan.where) {
+		const predicate = compileThreadPredicate(plan.where, values.length + 1);
+		threadPredicateSql = predicate.sql;
+		values.push(...predicate.values);
+	}
+	ctes.push(`qualified_threads AS (
+    SELECT t."threadId"
+    FROM thread_ids t
+    WHERE ${threadPredicateSql}
+  )`);
+	const pageCondition = plan.cursor ? `WHERE "threadId" > $${values.length + 1}` : "";
+	if (plan.cursor) values.push(plan.cursor.threadId);
+	values.push(plan.limit + 1);
+	return {
+		text: `WITH ${ctes.join(",\n")}
+SELECT "threadId"
+FROM qualified_threads
+${pageCondition}
+ORDER BY "threadId" ASC
+LIMIT $${values.length}`,
+		values
+	};
+}
 function asIsoTimestamp$1(value) {
 	if (value === null || value === void 0) throw new Error("Trace query returned a null timestamp");
 	return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
@@ -17561,6 +17689,19 @@ async function queryTraces(client, schema, plan, timeoutMs) {
 		}) : null }
 	});
 }
+async function queryThreads(client, schema, plan, timeoutMs) {
+	const query = compilePostgresThreadQuery(schema, plan);
+	const rows = await runWithPostgresTraceQueryTimeout(client, timeoutMs, (transaction) => transaction.any(query.text, query.values));
+	const threads = rows.slice(0, plan.limit).map((row) => ({ threadId: String(row.threadId) }));
+	const last = threads.at(-1);
+	return _mastra_core_storage.queryThreadsResultSchema.parse({
+		threads,
+		page: { next: rows.length > plan.limit && last ? _mastra_core_storage.encodeTraceQueryCursor(plan, {
+			result: "threads",
+			threadId: last.threadId
+		}) : null }
+	});
+}
 //#endregion
 //#region src/storage/domains/observability/v-next/traces.ts
 /**
@@ -18456,13 +18597,15 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 		if (!deltaPollingFeatureEnabled()) return [
 			"metrics",
 			"logs",
-			"trace-query"
+			"trace-query",
+			"thread-query"
 		];
 		return [
 			"metrics",
 			"logs",
 			"delta-polling",
-			"trace-query"
+			"trace-query",
+			"thread-query"
 		];
 	}
 	async #run(op, fn, details) {
@@ -18508,6 +18651,9 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 	async queryTraces(plan) {
 		return this.#run("QUERY_TRACES", () => queryTraces(this.#readClient, this.#schema, plan, this.#traceQueryTimeoutMs));
 	}
+	async queryThreads(plan) {
+		return this.#run("QUERY_THREADS", () => queryThreads(this.#readClient, this.#schema, plan, this.#traceQueryTimeoutMs));
+	}
 	async listBranches(args) {
 		return this.#run("LIST_BRANCHES", () => listBranches(this.#readClient, this.#schema, args));
 	}