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

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @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
+
+- Improved chat response time with PostgresStore. Message history now reads a page of messages and its total count in one query instead of two. When semantic recall is on, the recall read also starts at the same time as the page read. Each agent turn therefore makes fewer database round-trips, which is most noticeable on remote Postgres. ([#20979](https://github.com/mastra-ai/mastra/pull/20979))
+
+- Updated dependencies [[`cdd5c33`](https://github.com/mastra-ai/mastra/commit/cdd5c33ac6c7118a9f139e6dc0e14e6a8ae31658), [`d7cf7fa`](https://github.com/mastra-ai/mastra/commit/d7cf7fafc1ae1b50bd8462dd0e6c671a8606db93), [`0f9a448`](https://github.com/mastra-ai/mastra/commit/0f9a448502157e59f7b76f24360ad497168f5ef8), [`289f4ce`](https://github.com/mastra-ai/mastra/commit/289f4ce16e3293370440172132c52ee787cbc09f), [`4f16ff8`](https://github.com/mastra-ai/mastra/commit/4f16ff824bf2f9b0ddc93f210477c10c8a4fb1ab), [`1c67d85`](https://github.com/mastra-ai/mastra/commit/1c67d85e9da8285662f4dbbf47e0378c3fee0747), [`ba24be6`](https://github.com/mastra-ai/mastra/commit/ba24be662439c331ab23a600041f93803c89eca8), [`842b5fe`](https://github.com/mastra-ai/mastra/commit/842b5fe22b6a7fa811bd14e48eb9af523ac989f2), [`80bdf3a`](https://github.com/mastra-ai/mastra/commit/80bdf3ae16ade6ff63bde0cb16fa2df8ab7dd4dd), [`9ba1247`](https://github.com/mastra-ai/mastra/commit/9ba12470c77f1c03642d720ce67e517e878f666e), [`fd96298`](https://github.com/mastra-ai/mastra/commit/fd96298a8367622f4ebfcaa97b5b6c1fbbd14564), [`6a84954`](https://github.com/mastra-ai/mastra/commit/6a84954a2667f85b6d59da652dab1bbff007ccb0), [`52d8ef0`](https://github.com/mastra-ai/mastra/commit/52d8ef03801f1deb7ee48532fc4190dd4a33916c), [`cdd5c33`](https://github.com/mastra-ai/mastra/commit/cdd5c33ac6c7118a9f139e6dc0e14e6a8ae31658), [`efd5c81`](https://github.com/mastra-ai/mastra/commit/efd5c81cc25fde3c2ddd86fc1178deb4ec176e19), [`0976933`](https://github.com/mastra-ai/mastra/commit/0976933142333ec78451feef265b68bcb45aa5e7), [`242b945`](https://github.com/mastra-ai/mastra/commit/242b94558777bfbdeb42cbfea84afff0b6ad0633), [`fea5cae`](https://github.com/mastra-ai/mastra/commit/fea5caedc7e2cfea51784a15e015952692027abf), [`4b59f78`](https://github.com/mastra-ai/mastra/commit/4b59f786cbc9a7d1ef07a07517dbd4b96865e99d), [`7010c5d`](https://github.com/mastra-ai/mastra/commit/7010c5d15728bf9c5dfe4fb6b1bf80ce23bf143a)]:
+  - @mastra/core@1.58.0-alpha.3
+
 ## 1.20.0-alpha.0
 
 ### Minor 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.0"
+  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.0",
+  "version": "1.20.0-alpha.2",
   "package": "@mastra/pg",
   "exports": {},
   "modules": {}

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

@@ -251,6 +251,64 @@ const memoryStore = await storage.getStore('memory')
 const thread = await memoryStore?.getThreadById({ threadId: '...' })
 ```
 
+## Closing connections
+
+`close()` releases the connections of the stores a composite was built from: the `default` and `editor` stores, plus any domain that owns its own client. Each store is closed once, even when it backs several domains. When passed to the Mastra class, `close()` is called by `shutdown()`:
+
+```typescript
+import { MastraCompositeStore } from '@mastra/core/storage'
+import { PostgresStore } from '@mastra/pg'
+import { Mastra } from '@mastra/core'
+
+const pgStore = new PostgresStore({
+  id: 'pg-storage',
+  connectionString: process.env.DATABASE_URL,
+})
+
+export const mastra = new Mastra({
+  storage: new MastraCompositeStore({ id: 'composite', default: pgStore }),
+})
+
+process.on('SIGTERM', async () => {
+  // Releases the Postgres pool, so the process can exit
+  await mastra.shutdown()
+})
+```
+
+A store you construct only to supply a domain isn't reachable through the composite. Keep a reference to it and close it yourself:
+
+```typescript
+import { MastraCompositeStore } from '@mastra/core/storage'
+import { ClickhouseStore } from '@mastra/clickhouse'
+import { PostgresStore } from '@mastra/pg'
+import { Mastra } from '@mastra/core'
+
+const pgStore = new PostgresStore({
+  id: 'pg-storage',
+  connectionString: process.env.DATABASE_URL,
+})
+
+const clickhouseStore = new ClickhouseStore({
+  id: 'clickhouse-storage',
+  url: process.env.CLICKHOUSE_URL,
+  username: process.env.CLICKHOUSE_USERNAME,
+  password: process.env.CLICKHOUSE_PASSWORD,
+})
+
+export const mastra = new Mastra({
+  storage: new MastraCompositeStore({
+    id: 'composite',
+    default: pgStore,
+    domains: { observability: clickhouseStore.stores?.observability },
+  }),
+})
+
+process.on('SIGTERM', async () => {
+  await mastra.shutdown()
+  await clickhouseStore.close()
+})
+```
+
 ## Use cases
 
 ### Separate databases for different workloads

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}
         )`);
@@ -9413,6 +9425,38 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			throw mastraError;
 		}
 	}
+	/**
+	* Reads one page of messages together with the total row count.
+	*
+	* `COUNT(*) OVER ()` reports the count over the whole WHERE result on the same
+	* statement as the page, so the page costs one database round-trip instead of
+	* two. The page and the count also come from one snapshot, so the count always
+	* describes the returned rows. A separate `COUNT(*)` runs only when the page is
+	* empty and the caller asked for a page after the last row, because a window
+	* function has no row to carry the count on.
+	*/
+	async #fetchMessagePage({ selectStatement, tableName, whereClause, orderByStatement, queryParams, perPageInput, perPage, offset }) {
+		const limitClause = perPageInput === false ? "" : ` LIMIT $${queryParams.length + 1} OFFSET $${queryParams.length + 2}`;
+		const dataParams = perPageInput === false ? queryParams : [
+			...queryParams,
+			perPage,
+			offset
+		];
+		const rows = await this.#db.client.manyOrNone(`${selectStatement}, COUNT(*) OVER () AS "__total" FROM ${tableName} ${whereClause} ${orderByStatement}${limitClause}`, dataParams) || [];
+		if (rows.length > 0) return {
+			total: Number(rows[0].__total),
+			messages: rows
+		};
+		if (offset === 0) return {
+			total: 0,
+			messages: []
+		};
+		const countResult = await this.#db.client.one(`SELECT COUNT(*) FROM ${tableName} ${whereClause}`, queryParams);
+		return {
+			total: parseInt(countResult.count, 10),
+			messages: []
+		};
+	}
 	async listMessages(args) {
 		const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
 		const threadIds = (Array.isArray(threadId) ? threadId : [threadId]).filter((id) => typeof id === "string");
@@ -9469,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,
@@ -9487,23 +9534,30 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 					hasMore: false
 				};
 			}
+			let includeFailure;
+			const includePromise = include && include.length > 0 ? this._getIncludedMessages({
+				include,
+				resourceId
+			}).catch((error) => {
+				includeFailure = error;
+				return null;
+			}) : null;
 			let total;
 			let messages;
 			if (metadataFilter) {
 				const filteredRows = (await this.#db.client.manyOrNone(`${selectStatement} FROM ${tableName} ${whereClause} ${orderByStatement}`, queryParams) || []).filter((row) => (0, _mastra_core_storage.storageMessageMatchesMetadataFilter)(row.content, metadataFilter));
 				total = filteredRows.length;
 				messages = perPageInput === false ? filteredRows : filteredRows.slice(offset, offset + perPage);
-			} else {
-				const countResult = await this.#db.client.one(`SELECT COUNT(*) FROM ${tableName} ${whereClause}`, queryParams);
-				total = parseInt(countResult.count, 10);
-				const limitValue = perPageInput === false ? total : perPage;
-				const dataQuery = `${selectStatement} FROM ${tableName} ${whereClause} ${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
-				messages = [...await this.#db.client.manyOrNone(dataQuery, [
-					...queryParams,
-					limitValue,
-					offset
-				]) || []];
-			}
+			} else ({total, messages} = await this.#fetchMessagePage({
+				selectStatement,
+				tableName,
+				whereClause,
+				orderByStatement,
+				queryParams,
+				perPageInput,
+				perPage,
+				offset
+			}));
 			const primaryPageCount = messages.length;
 			if (total === 0 && messages.length === 0 && (!include || include.length === 0)) return {
 				messages: [],
@@ -9514,7 +9568,8 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			};
 			const messageIds = new Set(messages.map((m) => m.id));
 			if (include && include.length > 0) {
-				const includeMessages = await this._getIncludedMessages({ include });
+				const includeMessages = await includePromise;
+				if (includeFailure) throw includeFailure;
 				if (includeMessages) {
 					for (const includeMsg of includeMessages) if (!messageIds.has(includeMsg.id)) {
 						messages.push(includeMsg);
@@ -9604,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,
@@ -9622,23 +9680,30 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 					hasMore: false
 				};
 			}
+			let includeFailure;
+			const includePromise = include && include.length > 0 ? this._getIncludedMessages({
+				include,
+				resourceId
+			}).catch((error) => {
+				includeFailure = error;
+				return null;
+			}) : null;
 			let total;
 			let messages;
 			if (metadataFilter) {
 				const filteredRows = (await this.#db.client.manyOrNone(`${selectStatement} FROM ${tableName} ${whereClause} ${orderByStatement}`, queryParams) || []).filter((row) => (0, _mastra_core_storage.storageMessageMatchesMetadataFilter)(row.content, metadataFilter));
 				total = filteredRows.length;
 				messages = perPageInput === false ? filteredRows : filteredRows.slice(offset, offset + perPage);
-			} else {
-				const countResult = await this.#db.client.one(`SELECT COUNT(*) FROM ${tableName} ${whereClause}`, queryParams);
-				total = parseInt(countResult.count, 10);
-				const limitValue = perPageInput === false ? total : perPage;
-				const dataQuery = `${selectStatement} FROM ${tableName} ${whereClause} ${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
-				messages = [...await this.#db.client.manyOrNone(dataQuery, [
-					...queryParams,
-					limitValue,
-					offset
-				]) || []];
-			}
+			} else ({total, messages} = await this.#fetchMessagePage({
+				selectStatement,
+				tableName,
+				whereClause,
+				orderByStatement,
+				queryParams,
+				perPageInput,
+				perPage,
+				offset
+			}));
 			if (total === 0 && messages.length === 0 && (!include || include.length === 0)) return {
 				messages: [],
 				total: 0,
@@ -9648,7 +9713,8 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			};
 			const messageIds = new Set(messages.map((m) => m.id));
 			if (include && include.length > 0) {
-				const includeMessages = await this._getIncludedMessages({ include });
+				const includeMessages = await includePromise;
+				if (includeFailure) throw includeFailure;
 				if (includeMessages) {
 					for (const includeMsg of includeMessages) if (!messageIds.has(includeMsg.id)) {
 						messages.push(includeMsg);
@@ -18646,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);
@@ -20580,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.
@@ -20674,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({
@@ -21005,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;