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

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # @mastra/pg
 
+## 1.20.0-alpha.3
+
+### Patch Changes
+
+- Fixed generated thread titles being clobbered during a turn ([#21041](https://github.com/mastra-ai/mastra/pull/21041))
+
+  `updateThread` required both `title` and `metadata`, so callers that only needed to
+  change metadata (message persistence, working memory, observational memory, channel
+  subscriptions) had to read the thread and pass its title back. When title generation
+  finished between that read and the write, the freshly generated title was overwritten
+  with the stale one.
+
+  `title` and `metadata` are now independently optional: omitting one leaves that column
+  untouched. Callers that only change metadata no longer send a title, and message
+  persistence no longer rewrites a thread row it just read.
+
+- Updated dependencies [[`1c75e32`](https://github.com/mastra-ai/mastra/commit/1c75e32f7fc0b9fb6f548b4407feaec8a1440212), [`c47165c`](https://github.com/mastra-ai/mastra/commit/c47165c983c87594c6952f1fd2fa51a90205034c), [`e08e789`](https://github.com/mastra-ai/mastra/commit/e08e789c1bf4cd2fe46363f7a4728536ceccc9bd), [`35cc901`](https://github.com/mastra-ai/mastra/commit/35cc90102cf834a84827acaf9eee0b6d6d1e2a3b), [`a8b4cf0`](https://github.com/mastra-ai/mastra/commit/a8b4cf02823cffebc4751a53337dfacf097c1ae1), [`f33264f`](https://github.com/mastra-ai/mastra/commit/f33264f517ae603279afd5c4251e2b40f6dd3618), [`689f2c4`](https://github.com/mastra-ai/mastra/commit/689f2c4b6c0835fe455702b01d21daa8abcd9331), [`eeae63e`](https://github.com/mastra-ai/mastra/commit/eeae63e7fbe8e1f237adc69bca6e2ac13c5ca907), [`4c186a0`](https://github.com/mastra-ai/mastra/commit/4c186a017275f45e6ed4c09de0f89550e2d09e8c), [`b0fa077`](https://github.com/mastra-ai/mastra/commit/b0fa077bcbc9b08551846fe372a0d3d15b71ed72)]:
+  - @mastra/core@1.58.0-alpha.8
+
+## 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.3"
 ---
 
 ## 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.3",
   "package": "@mastra/pg",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-memory-semantic-recall.md

@@ -148,6 +148,7 @@ Each vector store page below includes installation instructions, configuration p
 - [libSQL](https://mastra.ai/reference/vectors/libsql)
 - [MongoDB](https://mastra.ai/reference/vectors/mongodb)
 - [OpenSearch](https://mastra.ai/reference/vectors/opensearch)
+- [OracleDB](https://mastra.ai/reference/vectors/oracledb)
 - [Pinecone](https://mastra.ai/reference/vectors/pinecone)
 - [PostgreSQL](https://mastra.ai/reference/vectors/pg)
 - [Qdrant](https://mastra.ai/reference/vectors/qdrant)
@@ -180,7 +181,7 @@ const agent = new Agent({
 })
 ```
 
-> **Note:** `scope: 'resource'` is supported by the LibSQL, PostgreSQL, MongoDB, and Upstash storage adapters.
+> **Note:** `scope: 'resource'` is supported by the LibSQL, OracleDB, PostgreSQL, MongoDB, and Upstash storage adapters.
 
 ### Metadata filtering
 

package/dist/docs/references/docs-memory-working-memory.md

@@ -129,6 +129,7 @@ Resource-scoped working memory requires specific storage adapters that support t
 
 - **libSQL** (`@mastra/libsql`)
 - **PostgreSQL** (`@mastra/pg`)
+- **OracleDB** (`@mastra/oracledb`)
 - **Upstash** (`@mastra/upstash`)
 - **MongoDB** (`@mastra/mongodb`)
 

package/dist/docs/references/docs-storage-overview.md

@@ -193,6 +193,7 @@ Each provider page includes installation instructions, configuration parameters,
 - [libSQL](https://mastra.ai/reference/storage/libsql)
 - [PostgreSQL](https://mastra.ai/reference/storage/postgresql)
 - [MongoDB](https://mastra.ai/reference/storage/mongodb)
+- [OracleDB](https://mastra.ai/reference/storage/oracledb)
 - [Upstash](https://mastra.ai/reference/storage/upstash)
 - [Redis](https://mastra.ai/reference/storage/redis)
 - [Cloudflare D1](https://mastra.ai/reference/storage/cloudflare-d1)

package/dist/docs/references/guides-rag-overview.md

@@ -67,7 +67,7 @@ The basic building block of RAG is document processing. Documents can be chunked
 
 ## Vector storage
 
-Mastra supports multiple vector stores for embedding persistence and similarity search, including pgvector, Pinecone, Qdrant, and MongoDB. See the [vector database doc](https://mastra.ai/guides/rag/vector-databases).
+Mastra supports multiple vector stores for embedding persistence and similarity search, including pgvector, OracleDB, Pinecone, Qdrant, and MongoDB. See the [vector database doc](https://mastra.ai/guides/rag/vector-databases).
 
 ## More resources
 

package/dist/docs/references/guides-rag-retrieval.md

@@ -436,6 +436,23 @@ export const ragAgent = new Agent({
 })
 ```
 
+**OracleDB**:
+
+```ts
+import { ORACLEDB_PROMPT } from '@mastra/oracledb'
+
+export const ragAgent = new Agent({
+  id: 'rag-agent',
+  name: 'RAG Agent',
+  model: 'openai/gpt-5.6-sol',
+  instructions: `
+  Process queries using the provided context. Structure responses to be concise and relevant.
+  ${ORACLEDB_PROMPT}
+  `,
+  tools: { vectorQueryTool },
+})
+```
+
 **S3Vectors**:
 
 ```ts

package/dist/docs/references/guides-rag-vector-databases.md

@@ -78,6 +78,35 @@ await store.upsert({
 
 PostgreSQL with the pgvector extension is a good solution for teams already using PostgreSQL who want to minimize infrastructure complexity. For detailed setup instructions and best practices, see the [official pgvector repository](https://github.com/pgvector/pgvector).
 
+**OracleDB**:
+
+```ts
+import { OracleVector } from '@mastra/oracledb'
+
+const store = new OracleVector({
+  id: 'oracle-vector',
+  user: process.env.ORACLE_DATABASE_USER,
+  password: process.env.ORACLE_DATABASE_PASSWORD,
+  connectString: process.env.ORACLE_DATABASE_CONNECT_STRING,
+})
+
+await store.createIndex({
+  indexName: 'myCollection',
+  dimension: 1536,
+  indexConfig: { type: 'none' },
+})
+
+await store.upsert({
+  indexName: 'myCollection',
+  vectors: embeddings,
+  metadata: chunks.map(chunk => ({ text: chunk.text })),
+})
+```
+
+### Using Oracle Database Vector Search
+
+OracleDB stores embeddings in native `VECTOR` columns and metadata in Oracle JSON. Exact search is the default; HNSW and IVF indexes can be configured for tuned deployments.
+
 **Pinecone**:
 
 ```ts
@@ -410,6 +439,18 @@ Index names must:
 - Example: `my_index_123` is valid
 - Example: `my-index` is not valid (contains hyphen)
 
+**OracleDB**:
+
+Index names are logical Mastra names. OracleDB maps each logical index to a physical Oracle table internally.
+
+Logical index names must:
+
+- Be non-empty
+- Be 512 characters or fewer
+- Be stable for the lifetime of the vector index
+- Example: `my_collection_123` is valid
+- Example: `customer-support/docs:v1` is valid and is mapped to a safe Oracle table name
+
 **Pinecone**:
 
 Index names must:

package/dist/docs/references/reference-rag-metadata-filters.md

@@ -2,7 +2,7 @@
 
 # Metadata filters
 
-Mastra provides a unified metadata filtering syntax across all vector stores, based on MongoDB/Sift query syntax. Each vector store translates these filters into their native format.
+Mastra provides a unified metadata filtering syntax across all vector stores, based on MongoDB/Sift query syntax. Each vector store translates these filters into its native query format. For example, PgVector uses PostgreSQL JSONB predicates, while OracleDB stores metadata as Oracle JSON and compiles filters to `JSON_VALUE`, `JSON_EXISTS`, `REGEXP_LIKE`, and `LIKE` predicates with bound values.
 
 ## Basic example
 
@@ -34,11 +34,11 @@ const results = await store.query({
 
 ### Array Operators
 
-`$in`Matches any value in array{ category: { $in: \["A", "B"] } }Supported by: All except Couchbase`$nin`Matches none of the values{ status: { $nin: \["deleted", "archived"] } }Supported by: All except Couchbase`$all`Matches arrays containing all elements{ tags: { $all: \["urgent", "high"] } }Supported by: Astra, Pinecone, Upstash, MongoDB`$elemMatch`Matches array elements meeting criteria{ scores: { $elemMatch: { $gt: 80 } } }Supported by: libSQL, PgVector, MongoDB
+`$in`Matches any value in array{ category: { $in: \["A", "B"] } }Supported by: All except Couchbase`$nin`Matches none of the values{ status: { $nin: \["deleted", "archived"] } }Supported by: All except Couchbase`$all`Matches arrays containing all elements{ tags: { $all: \["urgent", "high"] } }Supported by: Astra, Pinecone, Upstash, MongoDB, OracleDB`$elemMatch`Matches array elements meeting criteria{ scores: { $elemMatch: { $gt: 80 } } }Supported by: libSQL, PgVector, MongoDB, OracleDB
 
 ### Logical Operators
 
-`$and`Logical AND{ $and: \[{ price: { $gt: 100 } }, { stock: { $gt: 0 } }] }Supported by: All except Vectorize, Couchbase`$or`Logical OR{ $or: \[{ status: "active" }, { priority: "high" }] }Supported by: All except Vectorize, Couchbase`$not`Logical NOT{ price: { $not: { $lt: 100 } } }Supported by: Astra, Qdrant, Upstash, PgVector, libSQL, MongoDB`$nor`Logical NOR{ $nor: \[{ status: "deleted" }, { archived: true }] }Supported by: Qdrant, Upstash, PgVector, libSQL, MongoDB
+`$and`Logical AND{ $and: \[{ price: { $gt: 100 } }, { stock: { $gt: 0 } }] }Supported by: All except Vectorize, Couchbase`$or`Logical OR{ $or: \[{ status: "active" }, { priority: "high" }] }Supported by: All except Vectorize, Couchbase`$not`Logical NOT{ price: { $not: { $lt: 100 } } }Supported by: Astra, Qdrant, Upstash, PgVector, libSQL, MongoDB, OracleDB`$nor`Logical NOR{ $nor: \[{ status: "deleted" }, { archived: true }] }Supported by: Qdrant, Upstash, PgVector, libSQL, MongoDB, OracleDB
 
 ### Element Operators
 
@@ -46,7 +46,7 @@ const results = await store.query({
 
 ### Custom Operators
 
-`$contains`Text contains substring{ description: { $contains: "sale" } }Supported by: Upstash, libSQL, PgVector`$regex`Regular expression match{ name: { $regex: "^test" } }Supported by: Qdrant, PgVector, Upstash, MongoDB`$size`Array length check{ tags: { $size: { $gt: 2 } } }Supported by: Astra, libSQL, PgVector, MongoDB`$geo`Geospatial query{ location: { $geo: { type: "radius", ... } } }Supported by: Qdrant`$datetime`Datetime range query{ created: { $datetime: { range: { gt: "2024-01-01" } } } }Supported by: Qdrant`$hasId`Vector ID existence check{ $hasId: \["id1", "id2"] }Supported by: Qdrant`$hasVector`Vector existence check{ $hasVector: true }Supported by: Qdrant
+`$contains`Text contains substring{ description: { $contains: "sale" } }Supported by: Upstash, libSQL, PgVector, OracleDB`$regex`Regular expression match{ name: { $regex: "^test" } }Supported by: Qdrant, PgVector, Upstash, MongoDB, OracleDB`$size`Array length check{ tags: { $size: 3 } }Supported by: Astra, libSQL, PgVector, MongoDB, OracleDB`$geo`Geospatial query{ location: { $geo: { type: "radius", ... } } }Supported by: Qdrant`$datetime`Datetime range query{ created: { $datetime: { range: { gt: "2024-01-01" } } } }Supported by: Qdrant`$hasId`Vector ID existence check{ $hasId: \["id1", "id2"] }Supported by: Qdrant`$hasVector`Vector existence check{ $hasVector: true }Supported by: Qdrant
 
 ## Common rules and restrictions
 
@@ -124,6 +124,14 @@ const results = await store.query({
 - Empty arrays in conditions are handled gracefully
 - Metadata is stored in a JSONB column for efficient querying
 
+### OracleDB
+
+- Metadata is stored as Oracle JSON alongside each `VECTOR` row
+- Scalar comparisons use `JSON_VALUE`, while array, existence, and element-match checks use `JSON_EXISTS`
+- `$regex` uses Oracle `REGEXP_LIKE`; string `$contains` uses case-insensitive `LIKE`
+- Nested fields are supported with dot notation and are converted to quoted Oracle JSON paths
+- User-provided metadata values are bound as parameters instead of interpolated into SQL
+
 ### PgVector
 
 - Full support for PostgreSQL's native JSON querying capabilities
@@ -211,6 +219,7 @@ const results = await store.query({
 - [Cloudflare Vectorize](https://mastra.ai/reference/vectors/vectorize)
 - [libSQL](https://mastra.ai/reference/vectors/libsql)
 - [MongoDB](https://mastra.ai/reference/vectors/mongodb)
+- [OracleDB](https://mastra.ai/reference/vectors/oracledb)
 - [PgStore](https://mastra.ai/reference/vectors/pg)
 - [Pinecone](https://mastra.ai/reference/vectors/pinecone)
 - [Qdrant](https://mastra.ai/reference/vectors/qdrant)

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

@@ -9200,7 +9200,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			text: `Thread ${id} not found`,
 			details: {
 				threadId: id,
-				title
+				title: title ?? null
 			}
 		});
 		const mergedMetadata = {
@@ -9211,14 +9211,14 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 			const nowStr = toUtcISOString(/* @__PURE__ */ new Date());
 			const thread = await this.#db.client.one(`UPDATE ${threadTableName}
                     SET
-                        title = $1,
+                        title = COALESCE($1, title),
                         metadata = $2,
                         "updatedAt" = $3,
                         "updatedAtZ" = $4
                     WHERE id = $5
                     RETURNING *
                 `, [
-				title,
+				title ?? null,
 				mergedMetadata,
 				nowStr,
 				nowStr,
@@ -9239,7 +9239,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
 				details: {
 					threadId: id,
-					title
+					title: title ?? null
 				}
 			}, error);
 		}
@@ -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;