@mastra/pg 1.20.0-alpha.1 → 1.20.0-alpha.2

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @mastra/pg
 
+## 1.20.0-alpha.2
+
+### Patch Changes
+
+- Fixed `include` in `listMessages` and `listMessagesByResourceId` so it can no longer return a message that belongs to a different resource. When you pass a `resourceId`, the target message and its surrounding context messages now stay inside that resource. Includes that cross threads inside the same resource keep working, so semantic recall with `scope: 'resource'` is unchanged. ([#20984](https://github.com/mastra-ai/mastra/pull/20984))
+
+  **Behaviour change in the in-memory store**
+
+  The in-memory store read the context window from the thread you queried. It now reads the window from the thread that owns the target message, which is what the SQL stores already did. This only changes the result when an `include` entry names a message from another thread.
+
+  The in-memory store also ignored `include` in `listMessagesByResourceId`. It now returns the included messages, like `@mastra/libsql` and `@mastra/pg` do.
+
+  Fixes #20604.
+
+- Add a persistent `threadState` domain to `PostgresStore` ([#20994](https://github.com/mastra-ai/mastra/pull/20994))
+
+  `PostgresStore` did not register a `threadState` domain, so durable task and goal
+  state fell back to in-memory storage and was lost on restart. Anything relying on
+  thread state (task tools, long-running agent goals) could not be backed by Postgres
+  alone, and required composing a second adapter through `MastraCompositeStore`.
+
+  `ThreadStatePG` now stores state as JSONB keyed by `(threadId, type)` with an atomic
+  upsert that preserves `createdAt`, participates in `exportSchemas()` and `init()`, and
+  supports retention pruning anchored on `updatedAtZ` so state for still-active threads
+  survives age-based pruning.
+
+- Updated dependencies [[`6445eba`](https://github.com/mastra-ai/mastra/commit/6445eba6020abac681aba1cc9289f446cb400cbe), [`df31eb0`](https://github.com/mastra-ai/mastra/commit/df31eb0c7087d782a0d9346e467f9a4af4b0eef6), [`fcd0667`](https://github.com/mastra-ai/mastra/commit/fcd0667a4e378be35c9a1b1eb19cce78fbfd7282), [`bab06b1`](https://github.com/mastra-ai/mastra/commit/bab06b18923873a584bdfc71a6b4ec7fb4727fb7)]:
+  - @mastra/core@1.58.0-alpha.5
+
 ## 1.20.0-alpha.1
 
 ### Patch Changes

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.20.0-alpha.1"
+  version: "1.20.0-alpha.2"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.20.0-alpha.1",
+  "version": "1.20.0-alpha.2",
   "package": "@mastra/pg",
   "exports": {},
   "modules": {}

package/dist/docs/references/reference-storage-retention.md

@@ -92,7 +92,7 @@ Each domain declares which of its tables can be age-pruned and which timestamp c
 > - Experiments prune as whole units: an aged experiment's result rows are deleted together with it (results cascade with their parent), so a run is never left partially deleted. Retention doesn't have a separate `results` key.
 > - For `schedules`, the growth table is the fire history (`schedule_triggers`, one row per fire): schedule definitions are config and aren't pruned.
 > - On PostgreSQL, timestamp anchors use the timezone-aware mirror columns (for example `createdAtZ`, `completedAtZ`).
-> - LibSQL supports all domains above; PostgreSQL and MongoDB support all except `threadState` and `harness`, which they don't implement.
+> - LibSQL and PostgreSQL support all domains above except `harness`, which PostgreSQL doesn't implement. MongoDB supports all except `threadState` and `harness`.
 > - The v-next PostgreSQL observability domain stores signal events in day-partitioned tables (`spans`, `metrics`, `logs`, `scores`, `feedback`). For it, `prune()` drops whole day partitions (or TimescaleDB chunks) that are entirely older than the cutoff instead of deleting rows: effective level of detail is one day, and a partition is only dropped once its entire day is past `maxAge`. `PruneResult.deleted` reports the number of rows in the dropped partitions.
 
 ## Methods

package/dist/index.cjs

@@ -9307,7 +9307,13 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
 		});
 	}
-	async _getIncludedMessages({ include }) {
+	/**
+	* Fetches included messages by ID, discovering their thread automatically.
+	* This handles cross-thread includes where the include item doesn't specify a threadId.
+	* When a resourceId is given, both the target lookup and the surrounding window stay
+	* inside that resource, so an include never leaks another resource's messages.
+	*/
+	async _getIncludedMessages({ include, resourceId }) {
 		if (!include || include.length === 0) return null;
 		const tableName = getTableName$3({
 			indexName: _mastra_core_storage.TABLE_MESSAGES,
@@ -9317,7 +9323,8 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 		const targetIds = include.map((inc) => inc.id).filter(Boolean);
 		if (targetIds.length === 0) return null;
 		const idPlaceholders = targetIds.map((_, i) => "$" + (i + 1)).join(", ");
-		const targetRows = await this.#db.client.manyOrNone(`SELECT id, thread_id, "createdAt" FROM ${tableName} WHERE id IN (${idPlaceholders})`, targetIds);
+		const targetResourceCondition = resourceId ? ` AND "resourceId" = $${targetIds.length + 1}` : "";
+		const targetRows = await this.#db.client.manyOrNone(`SELECT id, thread_id, "createdAt" FROM ${tableName} WHERE id IN (${idPlaceholders})${targetResourceCondition}`, resourceId ? [...targetIds, resourceId] : targetIds);
 		if (targetRows.length === 0) return null;
 		const targetMap = new Map(targetRows.map((r) => [r.id, {
 			threadId: r.thread_id,
@@ -9325,7 +9332,12 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 		}]));
 		const unionQueries = [];
 		const params = [];
-		let paramIdx = 1;
+		let resourceCondition = "";
+		if (resourceId) {
+			params.push(resourceId);
+			resourceCondition = ` AND m."resourceId" = $1`;
+		}
+		let paramIdx = params.length + 1;
 		for (const inc of include) {
 			const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
 			const target = targetMap.get(id);
@@ -9337,7 +9349,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
         SELECT ${selectColumns}
         FROM ${tableName} m
         WHERE m.thread_id = ${p1}
-          AND m."createdAt" <= ${p2}
+          AND m."createdAt" <= ${p2}${resourceCondition}
         ORDER BY m."createdAt" DESC, m.id DESC
         LIMIT ${p3}
       )`);
@@ -9351,7 +9363,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
           SELECT ${selectColumns}
           FROM ${tableName} m
           WHERE m.thread_id = ${p4}
-            AND m."createdAt" > ${p5}
+            AND m."createdAt" > ${p5}${resourceCondition}
           ORDER BY m."createdAt" ASC, m.id ASC
           LIMIT ${p6}
         )`);
@@ -9501,7 +9513,10 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				hasMore: false
 			};
 			if (perPage === 0 && include && include.length > 0) {
-				const includeMessages = await this._getIncludedMessages({ include });
+				const includeMessages = await this._getIncludedMessages({
+					include,
+					resourceId
+				});
 				if (!includeMessages || includeMessages.length === 0) return {
 					messages: [],
 					total: 0,
@@ -9520,7 +9535,10 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				};
 			}
 			let includeFailure;
-			const includePromise = include && include.length > 0 ? this._getIncludedMessages({ include }).catch((error) => {
+			const includePromise = include && include.length > 0 ? this._getIncludedMessages({
+				include,
+				resourceId
+			}).catch((error) => {
 				includeFailure = error;
 				return null;
 			}) : null;
@@ -9641,7 +9659,10 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				hasMore: false
 			};
 			if (perPage === 0 && include && include.length > 0) {
-				const includeMessages = await this._getIncludedMessages({ include });
+				const includeMessages = await this._getIncludedMessages({
+					include,
+					resourceId
+				});
 				if (!includeMessages || includeMessages.length === 0) return {
 					messages: [],
 					total: 0,
@@ -9660,7 +9681,10 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				};
 			}
 			let includeFailure;
-			const includePromise = include && include.length > 0 ? this._getIncludedMessages({ include }).catch((error) => {
+			const includePromise = include && include.length > 0 ? this._getIncludedMessages({
+				include,
+				resourceId
+			}).catch((error) => {
 				includeFailure = error;
 				return null;
 			}) : null;
@@ -18688,6 +18712,171 @@ var SkillsPG = class SkillsPG extends _mastra_core_storage.SkillsStorage {
 	}
 };
 //#endregion
+//#region src/storage/domains/thread-state/index.ts
+const COMPOSITE_PRIMARY_KEY = ["threadId", "type"];
+/**
+* PostgreSQL implementation of {@link ThreadStateStorage}.
+*
+* Stores per-thread, per-type state in `mastra_thread_state`, keyed by the
+* composite primary key `(threadId, type)`. The `value` column is `jsonb`, so
+* payloads (the task list for `type = 'task'`, the goal objective for
+* `type = 'goal'`) come back already parsed.
+*/
+var ThreadStatePG = class ThreadStatePG extends _mastra_core_storage.ThreadStateStorage {
+	#db;
+	#schema;
+	static MANAGED_TABLES = [_mastra_core_storage.TABLE_THREAD_STATE];
+	/**
+	* `thread_state` grows as a side effect of thread activity (one row per
+	* thread per state type). It anchors on `updatedAtZ` (last activity), so
+	* state for a thread that is still being written to is not pruned by
+	* creation age.
+	*/
+	static retentionTables = { threadState: {
+		table: _mastra_core_storage.TABLE_THREAD_STATE,
+		column: "updatedAtZ",
+		indexed: true
+	} };
+	constructor(config) {
+		super();
+		const { client, schemaName, skipDefaultIndexes } = resolvePgConfig(config);
+		this.#db = new PgDB({
+			client,
+			schemaName,
+			skipDefaultIndexes
+		});
+		this.#schema = schemaName || "public";
+	}
+	static getExportDDL(schemaName) {
+		return [generateTableSQL({
+			tableName: _mastra_core_storage.TABLE_THREAD_STATE,
+			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_THREAD_STATE],
+			schemaName,
+			compositePrimaryKey: COMPOSITE_PRIMARY_KEY,
+			includeAllConstraints: true
+		})];
+	}
+	async init() {
+		await this.#db.createTable({
+			tableName: _mastra_core_storage.TABLE_THREAD_STATE,
+			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_THREAD_STATE],
+			compositePrimaryKey: COMPOSITE_PRIMARY_KEY
+		});
+	}
+	get #table() {
+		return getTableName$5({
+			indexName: _mastra_core_storage.TABLE_THREAD_STATE,
+			schemaName: getSchemaName$5(this.#schema)
+		});
+	}
+	/**
+	* Create the retention index on demand, mirroring the other PG domains: only
+	* deployments that configure retention pay for the extra index. Best-effort —
+	* a failure here leaves pruning correct, just slower.
+	*/
+	async #ensureRetentionIndexes(policies) {
+		const prefix = this.#schema && this.#schema !== "public" ? `${this.#schema}_` : "";
+		for (const [key, entry] of Object.entries(ThreadStatePG.retentionTables)) {
+			if (!entry.indexed || !policies[key]) continue;
+			try {
+				await this.#db.ensureIndex({
+					indexName: `${prefix}mastra_${key}_retention_idx`,
+					tableName: entry.table,
+					column: entry.column
+				});
+			} catch (error) {
+				this.logger?.warn?.(`Failed to create retention index for ${entry.table}:`, error);
+			}
+		}
+	}
+	/** Delete thread state older than the `threadState` policy's `maxAge`, batched. */
+	async prune(policies, options) {
+		await this.#ensureRetentionIndexes(policies);
+		const targets = resolveTargets({
+			policies,
+			descriptor: ThreadStatePG.retentionTables,
+			order: ["threadState"]
+		});
+		return runPrune({
+			db: this.#db,
+			domain: "threadState",
+			targets,
+			options
+		});
+	}
+	async dangerouslyClearAll() {
+		try {
+			await this.#db.client.none(`DELETE FROM ${this.#table}`);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "THREAD_STATE_CLEAR_ALL", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY
+			}, error);
+		}
+	}
+	async getState({ threadId, type }) {
+		try {
+			const row = await this.#db.client.oneOrNone(`SELECT "value" FROM ${this.#table} WHERE "threadId" = $1 AND "type" = $2 LIMIT 1`, [threadId, type]);
+			if (!row || row.value === null || row.value === void 0) return void 0;
+			return typeof row.value === "string" ? JSON.parse(row.value) : row.value;
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "THREAD_STATE_GET", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					threadId,
+					type
+				}
+			}, error);
+		}
+	}
+	async setState({ threadId, type, value }) {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const serialized = JSON.stringify(value ?? null);
+		try {
+			await this.#db.client.none(`INSERT INTO ${this.#table} ("threadId", "type", "value", "createdAt", "createdAtZ", "updatedAt", "updatedAtZ")
+         VALUES ($1, $2, $3::jsonb, $4::timestamp, $5::timestamptz, $4::timestamp, $5::timestamptz)
+         ON CONFLICT ("threadId", "type")
+         DO UPDATE SET "value" = EXCLUDED."value",
+                       "updatedAt" = EXCLUDED."updatedAt",
+                       "updatedAtZ" = EXCLUDED."updatedAtZ"`, [
+				threadId,
+				type,
+				serialized,
+				now,
+				now
+			]);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "THREAD_STATE_SET", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					threadId,
+					type
+				}
+			}, error);
+		}
+	}
+	async deleteState({ threadId, type }) {
+		try {
+			await this.#db.client.none(`DELETE FROM ${this.#table} WHERE "threadId" = $1 AND "type" = $2`, [threadId, type]);
+		} catch (error) {
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "THREAD_STATE_DELETE", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: {
+					threadId,
+					type
+				}
+			}, error);
+		}
+	}
+};
+//#endregion
 //#region src/storage/domains/tool-provider-connections/index.ts
 function normaliseScope(raw) {
 	const value = raw == null ? "per-author" : String(raw);
@@ -20622,7 +20811,8 @@ const ALL_DOMAINS = [
 	BackgroundTasksPG,
 	FavoritesPG,
 	ChannelsPG,
-	SchedulesPG
+	SchedulesPG,
+	ThreadStatePG
 ];
 /**
 * Exports the Mastra database schema as SQL DDL statements, including tables, indexes, and triggers.
@@ -20716,7 +20906,8 @@ var PostgresStore = class extends _mastra_core_storage.MastraCompositeStore {
 				experiments: new ExperimentsPG(domainConfig),
 				backgroundTasks: new BackgroundTasksPG(domainConfig),
 				channels: new ChannelsPG(domainConfig),
-				schedules: new SchedulesPG(domainConfig)
+				schedules: new SchedulesPG(domainConfig),
+				threadState: new ThreadStatePG(domainConfig)
 			};
 		} catch (e) {
 			throw new _mastra_core_error.MastraError({
@@ -21047,6 +21238,7 @@ exports.SchedulesPG = SchedulesPG;
 exports.ScorerDefinitionsPG = ScorerDefinitionsPG;
 exports.ScoresPG = ScoresPG;
 exports.SkillsPG = SkillsPG;
+exports.ThreadStatePG = ThreadStatePG;
 exports.ToolProviderConnectionsPG = ToolProviderConnectionsPG;
 exports.WorkflowDefinitionsPG = WorkflowDefinitionsPG;
 exports.WorkflowsPG = WorkflowsPG;