@mastra/pg 1.26.0-alpha.2 → 1.26.0-alpha.4

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.26.0-alpha.2"
+  version: "1.26.0-alpha.4"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

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

package/dist/docs/references/reference-memory-memory-class.md

@@ -51,7 +51,7 @@ export const agent = new Agent({
 
 **options.observationalMemory** (`boolean | ObservationalMemoryOptions`): Enable Observational Memory for long-context agentic memory. Set to true for defaults, or pass a config object to customize token budgets, models, and scope. See Observational Memory reference for configuration details.
 
-**options.generateTitle** (`boolean | { model: DynamicArgument<MastraLanguageModel>; instructions?: DynamicArgument<string> }`): Controls automatic thread title generation from the conversation transcript. Can be a boolean or an object with custom model and instructions.
+**options.generateTitle** (`boolean | { model?: DynamicArgument<MastraModelConfig>; instructions?: DynamicArgument<string>; minMessages?: number; emitEvent?: boolean }`): Controls automatic thread title generation from the conversation transcript. Accepts a boolean or an object with a custom model (any MastraModelConfig: a model instance, a "provider/model" ID, or an OpenAI-compatible config; defaults to the agent's own model), custom instructions, a minimum message count, and emitEvent. With emitEvent: true the run's stream waits for the title and emits it as a transient data-thread-title chunk before finish (durable and evented agents persist the title but don't emit the chunk yet).
 
 ## Returns
 

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

@@ -345,6 +345,29 @@ await store.upsert({
 
 For detailed setup instructions and best practices, see the [official Elasticsearch documentation](https://www.elastic.co/docs/solutions/search/get-started).
 
+**Azure AI Search**:
+
+```ts
+import { AzureAISearchVector } from '@mastra/azure-ai-search'
+
+const store = new AzureAISearchVector({
+  id: 'azure-search-vectors',
+  endpoint: process.env.AZURE_AI_SEARCH_ENDPOINT!,
+  credential: process.env.AZURE_AI_SEARCH_CREDENTIAL!,
+})
+
+await store.createIndex({
+  indexName: 'my-collection',
+  dimension: 1536,
+})
+
+await store.upsert({
+  indexName: 'my-collection',
+  vectors: embeddings,
+  metadata: chunks.map(chunk => ({ text: chunk.text })),
+})
+```
+
 **Couchbase**:
 
 ```ts
@@ -626,6 +649,17 @@ Index names must:
 - Example: `myindex-` isn't valid (ends with hyphen)
 - Example: `MyIndex` isn't valid (contains uppercase letters)
 
+**Azure AI Search**:
+
+Index names must:
+
+- Use only lowercase letters, numbers, dashes (`-`), and underscore (`_`) characters
+- Not start or end with a dash
+- Be between 2 and 128 characters long
+- Example: `my-index-123` and `my_index` are valid
+- Example: `MyIndex` isn't valid (contains uppercase letters)
+- Example: `my-index-` isn't valid (ends with a dash)
+
 ### Upserting Embeddings
 
 After creating an index, you can store embeddings along with their basic metadata:

package/dist/index.cjs

@@ -2360,6 +2360,8 @@ var RoutingDbClient = class {
 		return this.active.tx(callback);
 	}
 };
+/** Bytes reserved for the `_xxxxxxxx` collision suffix when hashWhenTruncated applies. */
+const TRUNCATION_HASH_SUFFIX_LENGTH = 9;
 function truncateIdentifier(value, maxLength = 63) {
 	if (maxLength <= 0) return "";
 	if (Buffer.byteLength(value, "utf-8") <= maxLength) return value;
@@ -2380,9 +2382,25 @@ function truncateIdentifier(value, maxLength = 63) {
 * in system catalogs (pg_constraint.conname, pg_indexes.indexname, etc.).
 * Without this normalisation, runtime lookups that compare a mixed-case name
 * against the catalog would silently fail.
+*
+* With `hashWhenTruncated`, a name that exceeds the limit is truncated further
+* to make room for `_` + 8 hex chars of the full name's sha256. Plain
+* truncation cuts the tail, so two names sharing a long `<schema>_<prefix>`
+* collapse to the same identifier and `CREATE INDEX IF NOT EXISTS` (which
+* matches by name only) silently skips the second one. The suffix is
+* deterministic, so creation, warm-init snapshot checks, and DDL export all
+* agree on the same name. Opt-in because renaming already-released constraint
+* names would orphan the existing objects in deployed catalogs.
 */
-function buildConstraintName({ baseName, schemaName, maxLength = 63 }) {
-	return truncateIdentifier(`${schemaName ? `${schemaName}_` : ""}${baseName}`.toLowerCase(), maxLength);
+function buildConstraintName({ baseName, schemaName, maxLength = 63, hashWhenTruncated = false }) {
+	const fullName = `${schemaName ? `${schemaName}_` : ""}${baseName}`.toLowerCase();
+	if (hashWhenTruncated && Buffer.byteLength(fullName, "utf-8") > maxLength) {
+		const suffixLength = Math.min(TRUNCATION_HASH_SUFFIX_LENGTH, maxLength);
+		if (suffixLength < 2) return truncateIdentifier(fullName, maxLength);
+		const hash = (0, crypto$1.createHash)("sha256").update(fullName).digest("hex").slice(0, suffixLength - 1);
+		return `${truncateIdentifier(fullName, maxLength - suffixLength)}_${hash}`;
+	}
+	return truncateIdentifier(fullName, maxLength);
 }
 //#endregion
 //#region src/storage/db/pg-errors.ts
@@ -10782,7 +10800,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 				hasMore: false
 			};
 			const limitValue = perPageInput === false ? total : perPage;
-			const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "createdAtZ", "updatedAt", "updatedAtZ" ${baseQuery} ORDER BY COALESCE("${field}Z", "${field}") ${direction} LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`;
+			const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "createdAtZ", "updatedAt", "updatedAtZ" ${baseQuery} ORDER BY COALESCE("${field}Z", "${field}") ${direction}, "id" ${direction} LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`;
 			return {
 				threads: (await this.#db.readClient.manyOrNone(dataQuery, [
 					...queryParams,
@@ -10975,10 +10993,11 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 		return messages.sort((a, b) => {
 			const aValue = field === "createdAt" ? new Date(a.createdAt).getTime() : a[field];
 			const bValue = field === "createdAt" ? new Date(b.createdAt).getTime() : b[field];
-			if (aValue == null && bValue == null) return a.id.localeCompare(b.id);
+			const idOrder = direction === "ASC" ? a.id.localeCompare(b.id) : b.id.localeCompare(a.id);
+			if (aValue == null && bValue == null) return idOrder;
 			if (aValue == null) return 1;
 			if (bValue == null) return -1;
-			if (aValue === bValue) return a.id.localeCompare(b.id);
+			if (aValue === bValue) return idOrder;
 			if (typeof aValue === "number" && typeof bValue === "number") return direction === "ASC" ? aValue - bValue : bValue - aValue;
 			return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
 		});
@@ -11181,7 +11200,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 		const metadataFilter = (0, _mastra_core_storage.validateStorageMetadataFilter)(filter?.metadata);
 		try {
 			const { field, direction } = this.parseOrderBy(orderBy, "ASC");
-			const orderByStatement = `ORDER BY "${field}" ${direction}`;
+			const orderByStatement = `ORDER BY "${field}" ${direction}, "id" ${direction}`;
 			const selectStatement = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
 			const tableName = getTableName$3({
 				indexName: _mastra_core_storage.TABLE_MESSAGES,
@@ -11336,7 +11355,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 		const metadataFilter = (0, _mastra_core_storage.validateStorageMetadataFilter)(filter?.metadata);
 		try {
 			const { field, direction } = this.parseOrderBy(orderBy, "ASC");
-			const orderByStatement = `ORDER BY "${field}" ${direction}`;
+			const orderByStatement = `ORDER BY "${field}" ${direction}, "id" ${direction}`;
 			const selectStatement = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
 			const tableName = getTableName$3({
 				indexName: _mastra_core_storage.TABLE_MESSAGES,
@@ -14831,6 +14850,11 @@ function tableIndexes() {
 			columns: "(\"tags\")",
 			using: "gin"
 		},
+		{
+			name: "mastra_score_events_scoreid_cursor_idx",
+			table: TABLE_SCORE_EVENTS,
+			columns: "(\"scoreId\", \"cursorId\" DESC)"
+		},
 		{
 			name: "mastra_score_events_cursor_idx",
 			table: TABLE_SCORE_EVENTS,
@@ -16963,13 +16987,32 @@ function pushScoreIdentity(acc, scorerId, scoreSource) {
 		acc.params.push(scoreSource);
 	}
 }
+function scoreRewriteConflict(row) {
+	return `ON CONFLICT ("scoreId", "timestamp") DO UPDATE SET ${[
+		...Object.keys(row).filter((column) => column !== "scoreId" && column !== "timestamp").map((column) => `"${column}" = EXCLUDED."${column}"`),
+		"\"cursorId\" = EXCLUDED.\"cursorId\"",
+		"\"xactId\" = EXCLUDED.\"xactId\""
+	].join(", ")}`;
+}
+function collapseExactScoreConflicts(rows) {
+	const records = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const timestamp = new Date(row.timestamp).toISOString();
+		const key = `${String(row.scoreId)}\u0000${timestamp}`;
+		records.delete(key);
+		records.set(key, row);
+	}
+	return [...records.values()];
+}
 async function createScore(client, schema, args) {
-	const insert = buildInsert(schema, TABLE_SCORE_EVENTS, [scoreRecordToRow(args.score)]);
+	const row = scoreRecordToRow(args.score);
+	const insert = buildInsert(schema, TABLE_SCORE_EVENTS, [row], scoreRewriteConflict(row));
 	if (insert) await client.query(insert.text, insert.values);
 }
 async function batchCreateScores(client, schema, args) {
 	if (args.scores.length === 0) return;
-	const insert = buildInsert(schema, TABLE_SCORE_EVENTS, args.scores.map(scoreRecordToRow));
+	const rows = collapseExactScoreConflicts(args.scores.map(scoreRecordToRow));
+	const insert = buildInsert(schema, TABLE_SCORE_EVENTS, rows, scoreRewriteConflict(rows[0]));
 	if (insert) await client.query(insert.text, insert.values);
 }
 /**
@@ -16992,6 +17035,16 @@ async function deleteScores(client, schema, args) {
 	}
 	await client.query(`DELETE FROM ${table} WHERE ${conditions.join(" AND ")}`, values);
 }
+function latestScorePredicate(table, alias = "s") {
+	return `NOT EXISTS (
+    SELECT 1 FROM ${table} newer
+    WHERE newer."scoreId" = ${alias}."scoreId"
+      AND newer."cursorId" > ${alias}."cursorId"
+  )`;
+}
+function applyLatestScorePredicate(acc, table) {
+	acc.conditions.push(latestScorePredicate(table));
+}
 async function listScores(client, schema, args) {
 	const { mode, filters, pagination, orderBy, after, limit } = _mastra_core_storage.listScoresArgsSchema.parse(args);
 	const table = qualifiedTable(schema, TABLE_SCORE_EVENTS);
@@ -17002,28 +17055,50 @@ async function listScores(client, schema, args) {
 	return listScoresPage(client, table, filters, pagination.page, pagination.perPage, orderBy.field, orderBy.direction);
 }
 async function getScoreById(client, schema, scoreId) {
+	const table = qualifiedTable(schema, TABLE_SCORE_EVENTS);
 	const row = await client.oneOrNone(`SELECT ${SCORE_SELECT_COLUMNS}
-     FROM ${qualifiedTable(schema, TABLE_SCORE_EVENTS)}
+     FROM ${table}
      WHERE "scoreId" = $1
-     ORDER BY "timestamp" DESC
+     ORDER BY "cursorId" DESC
      LIMIT 1`, [scoreId]);
 	return row ? rowToScoreRecord(row) : null;
 }
 async function listScoresPage(client, table, filters, page, perPage, orderField, orderDir) {
-	return listSignalPage({
+	const acc = newFilterAccumulator();
+	applyScoreFilters(acc, filters);
+	applyLatestScorePredicate(acc, table);
+	const whereClause = whereOrEmpty(acc);
+	const countRow = await client.oneOrNone(`SELECT COUNT(*)::text AS count FROM ${table} s ${whereClause}`, acc.params);
+	const total = Number(countRow?.count ?? 0);
+	let scores = [];
+	if (total > 0) {
+		const safeOrderField = (0, _mastra_core_utils.parseSqlIdentifier)(orderField, "order field");
+		scores = (await client.manyOrNone(`SELECT ${SCORE_SELECT_COLUMNS}
+       FROM ${table} s
+       ${whereClause}
+       ORDER BY "${safeOrderField}" ${orderDir}, "cursorId" ${orderDir}
+       LIMIT $${acc.next++} OFFSET $${acc.next++}`, [
+			...acc.params,
+			perPage,
+			page * perPage
+		])).map(rowToScoreRecord);
+	}
+	const deltaCursor = deltaPollingFeatureEnabled() ? await readSignalStreamHeadCursor({
 		client,
 		table,
 		filters,
-		page,
-		perPage,
-		orderField,
-		orderDir,
-		includeDeltaCursor: deltaPollingFeatureEnabled(),
-		selectColumns: SCORE_SELECT_COLUMNS,
-		responseKey: "scores",
-		applyFilters: applyScoreFilters,
-		mapRow: rowToScoreRecord
-	});
+		applyFilters: applyScoreFilters
+	}) : void 0;
+	return {
+		scores,
+		pagination: {
+			total,
+			page,
+			perPage,
+			hasMore: (page + 1) * perPage < total
+		},
+		...deltaCursor !== void 0 ? { deltaCursor } : {}
+	};
 }
 async function listScoresDelta(client, table, filters, after, limit) {
 	return listSignalDelta({
@@ -17039,12 +17114,14 @@ async function listScoresDelta(client, table, filters, after, limit) {
 	});
 }
 async function runScoreAggregateQuery(client, schema, args, filters) {
+	const table = qualifiedTable(schema, TABLE_SCORE_EVENTS);
 	const acc = newFilterAccumulator();
 	pushScoreIdentity(acc, args.scorerId, args.scoreSource);
 	applyScoreFilters(acc, filters);
+	applyLatestScorePredicate(acc, table);
 	const sql = `
     SELECT ${aggregationSql(args.aggregation, "\"score\"")} AS "value"
-    FROM ${qualifiedTable(schema, TABLE_SCORE_EVENTS)}
+    FROM ${table} s
     ${whereOrEmpty(acc)}
   `;
 	const row = await client.oneOrNone(sql, acc.params);
@@ -17076,10 +17153,12 @@ async function getScoreBreakdown(client, schema, args) {
 	});
 	pushScoreIdentity(acc, args.scorerId, args.scoreSource);
 	applyScoreFilters(acc, args.filters);
+	const table = qualifiedTable(schema, TABLE_SCORE_EVENTS);
+	applyLatestScorePredicate(acc, table);
 	const sql = `
     SELECT ${resolved.map((e) => e.selectSql).join(", ")},
            ${aggregationSql(args.aggregation, "\"score\"")} AS "value"
-    FROM ${qualifiedTable(schema, TABLE_SCORE_EVENTS)}
+    FROM ${table} s
     ${whereOrEmpty(acc)}
     GROUP BY ${resolved.map((e) => e.alias).join(", ")}
     ORDER BY "value" DESC NULLS LAST
@@ -17099,11 +17178,13 @@ async function getScoreTimeSeries(client, schema, args) {
 		});
 		pushScoreIdentity(acc, args.scorerId, args.scoreSource);
 		applyScoreFilters(acc, args.filters);
+		const table = qualifiedTable(schema, TABLE_SCORE_EVENTS);
+		applyLatestScorePredicate(acc, table);
 		const sql = `
       SELECT ${bucket} AS bucket,
              ${resolved.map((e) => e.selectSql).join(", ")},
              ${aggregationSql(args.aggregation, "\"score\"")} AS "value"
-      FROM ${qualifiedTable(schema, TABLE_SCORE_EVENTS)}
+      FROM ${table} s
       ${whereOrEmpty(acc)}
       GROUP BY bucket, ${resolved.map((e) => e.alias).join(", ")}
       ORDER BY bucket
@@ -17121,10 +17202,12 @@ async function getScoreTimeSeries(client, schema, args) {
 	const acc = newFilterAccumulator();
 	pushScoreIdentity(acc, args.scorerId, args.scoreSource);
 	applyScoreFilters(acc, args.filters);
+	const table = qualifiedTable(schema, TABLE_SCORE_EVENTS);
+	applyLatestScorePredicate(acc, table);
 	const sql = `
     SELECT ${bucket} AS bucket,
            ${aggregationSql(args.aggregation, "\"score\"")} AS "value"
-    FROM ${qualifiedTable(schema, TABLE_SCORE_EVENTS)}
+    FROM ${table} s
     ${whereOrEmpty(acc)}
     GROUP BY bucket
     ORDER BY bucket
@@ -17144,9 +17227,11 @@ async function getScorePercentiles(client, schema, args) {
 	const acc = newFilterAccumulator();
 	pushScoreIdentity(acc, args.scorerId, args.scoreSource);
 	applyScoreFilters(acc, args.filters);
+	const table = qualifiedTable(schema, TABLE_SCORE_EVENTS);
+	applyLatestScorePredicate(acc, table);
 	const sql = `
     SELECT ${bucket} AS bucket, ${percentileSelectSql(args.percentiles, "\"score\"")}
-    FROM ${qualifiedTable(schema, TABLE_SCORE_EVENTS)}
+    FROM ${table} s
     ${whereOrEmpty(acc)}
     GROUP BY bucket
     ORDER BY bucket
@@ -17345,13 +17430,6 @@ function latestSpanPredicate$1(spanTable) {
       AND (newer."isPending" < s."isPending" OR (newer."isPending" = s."isPending" AND newer."cursorId" > s."cursorId"))
   )`;
 }
-function latestScorePredicate(scoreTable) {
-	return `NOT EXISTS (
-    SELECT 1 FROM ${scoreTable} newer
-    WHERE newer."scoreId" = s."scoreId"
-      AND newer."cursorId" > s."cursorId"
-  )`;
-}
 function latestFeedbackPredicate(feedbackTable) {
 	return `NOT EXISTS (
     SELECT 1 FROM ${feedbackTable} newer
@@ -17521,7 +17599,7 @@ function compilePostgresTraceScope(schema, selection, relationCollections) {
 		values
 	};
 }
-function compilePostgresTraceQuery(schema, plan) {
+function compilePostgresTraceQuery(schema, plan, mode = "data") {
 	const { ctes, values } = compilePostgresTraceScope(schema, plan, collectRelationCollections(plan.where));
 	let predicateSql = "TRUE";
 	if (plan.where) {
@@ -17535,6 +17613,12 @@ function compilePostgresTraceQuery(schema, plan) {
     WHERE ${predicateSql}
   )`);
 	const candidates = `WITH ${ctes.join(",\n")}`;
+	if (plan.paginationMode === "page" && mode === "count") return {
+		text: `${candidates}
+SELECT COUNT(*)::text AS count
+FROM candidates`,
+		values
+	};
 	if (plan.result === "groups") {
 		const pageCondition = plan.cursor ? `AND "threadId" > $${values.length + 1}` : "";
 		if (plan.cursor) values.push(plan.cursor.threadId);
@@ -17552,6 +17636,17 @@ LIMIT $${values.length}`,
 	}
 	const orderField = plan.orderBy.field === "startedAt" ? "\"startedAt\"" : "\"endedAt\"";
 	const direction = plan.orderBy.direction === "asc" ? "ASC" : "DESC";
+	if (plan.paginationMode === "page") {
+		values.push(plan.perPage, plan.page * plan.perPage);
+		return {
+			text: `${candidates}
+SELECT *
+FROM candidates
+ORDER BY ${orderField} ${direction}, "traceId" ASC
+LIMIT $${values.length - 1} OFFSET $${values.length}`,
+			values
+		};
+	}
 	let pageCondition = "";
 	if (plan.cursor) {
 		const comparison = plan.orderBy.direction === "asc" ? ">" : "<";
@@ -17698,10 +17793,11 @@ function isPostgresResourceLimit(error) {
 	const candidate = error;
 	return candidate.code === "53200" || candidate.code === "53400";
 }
-async function runWithPostgresTraceQueryTimeout(client, timeoutMs, execute) {
+async function runWithPostgresTraceQueryTimeout(client, timeoutMs, execute, options = {}) {
 	const resolvedTimeoutMs = _mastra_core_storage.resolveTraceQueryTimeoutMs(timeoutMs);
 	try {
 		return await client.tx(async (transaction) => {
+			if (options.repeatableRead) await transaction.query("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ");
 			await transaction.query(`SELECT set_config('statement_timeout', $1, true)`, [`${resolvedTimeoutMs}ms`]);
 			return execute(transaction);
 		});
@@ -17735,6 +17831,50 @@ async function getTraceQueryValues(client, schema, plan, timeoutMs) {
 	});
 }
 async function queryTraces(client, schema, plan, timeoutMs) {
+	if (plan.paginationMode === "page") {
+		const resolvedTimeoutMs = _mastra_core_storage.resolveTraceQueryTimeoutMs(timeoutMs);
+		const deadline = performance.now() + resolvedTimeoutMs;
+		const countQuery = compilePostgresTraceQuery(schema, plan, "count");
+		const dataQuery = compilePostgresTraceQuery(schema, plan);
+		const { total, rows } = await runWithPostgresTraceQueryTimeout(client, resolvedTimeoutMs, async (transaction) => {
+			const countRows = await transaction.any(countQuery.text, countQuery.values);
+			const remainingTimeoutMs = Math.floor(deadline - performance.now());
+			if (remainingTimeoutMs <= 0) throw new _mastra_core_storage.TraceQueryExecutionError();
+			await transaction.query(`SELECT set_config('statement_timeout', $1, true)`, [`${remainingTimeoutMs}ms`]);
+			const rows = await transaction.any(dataQuery.text, dataQuery.values);
+			return {
+				total: Number(countRows[0]?.count ?? 0),
+				rows
+			};
+		}, { repeatableRead: true });
+		const traces = rows.map((row) => ({
+			traceId: String(row.traceId),
+			rootSpanId: String(row.rootSpanId),
+			name: row.name,
+			entityId: row.entityId ?? null,
+			parentSpanId: row.parentSpanId ?? null,
+			createdAt: asIsoTimestamp$1(row.startedAt),
+			metadata: row.metadata ?? null,
+			inputPreview: _mastra_core_storage.buildInputPreview(row.input) ?? null,
+			threadId: row.threadId == null ? null : String(row.threadId),
+			resourceId: row.resourceId == null ? null : String(row.resourceId),
+			startedAt: asIsoTimestamp$1(row.startedAt),
+			endedAt: asIsoTimestamp$1(row.endedAt),
+			entityName: row.entityName == null ? null : String(row.entityName),
+			entityType: row.entityType == null ? null : String(row.entityType),
+			environment: row.environment == null ? null : String(row.environment),
+			status: row.status
+		}));
+		return _mastra_core_storage.traceQueryResponseSchema.parse({
+			traces,
+			pagination: {
+				total,
+				page: plan.page,
+				perPage: plan.perPage,
+				hasMore: (plan.page + 1) * plan.perPage < total
+			}
+		});
+	}
 	const query = compilePostgresTraceQuery(schema, plan);
 	const rows = await runWithPostgresTraceQueryTimeout(client, timeoutMs, (transaction) => transaction.any(query.text, query.values));
 	const visibleRows = rows.slice(0, plan.limit);
@@ -22195,6 +22335,7 @@ const WORKFLOW_SNAPSHOT_STATUS_INDEX = "mastra_workflow_snapshot_name_status_cre
 * Schema-prefixed name of the status index, lowercased and truncated the same way Postgres
 * stores it, so the init snapshot's index set answers "does it exist?" without a probe or a
 * no-op `CREATE INDEX` (schema-prefixed names routinely exceed the 63-byte limit).
+* Exported for tests.
 */
 function workflowSnapshotStatusIndexName(schemaName) {
 	return buildConstraintName({
@@ -22212,6 +22353,48 @@ function workflowSnapshotStatusIndexSQL(indexName, schemaName) {
 		schemaName: getSchemaName(schemaName)
 	})} (workflow_name, (snapshot ->> 'status'), "createdAt" DESC)`;
 }
+/** Base name (before any schema prefix) of the expression index backing the threadId filter. */
+const WORKFLOW_SNAPSHOT_THREAD_ID_INDEX = "mastra_workflow_snapshot_threadid_idx";
+/**
+* Schema-prefixed name of the threadId index (see workflowSnapshotStatusIndexName).
+*
+* Unlike the status index, truncation appends a collision hash: both index names share the
+* long `<schema>_mastra_workflow_snapshot_` prefix, so with a schema name of 37+ bytes plain
+* truncation collapses them to the same 63-byte identifier and `CREATE INDEX IF NOT EXISTS`
+* silently skips this index. The status index keeps plain truncation because its truncated
+* name already exists in deployed catalogs; this index is new and free to adopt the rule.
+* Exported for tests.
+*/
+function workflowSnapshotThreadIdIndexName(schemaName) {
+	return buildConstraintName({
+		baseName: WORKFLOW_SNAPSHOT_THREAD_ID_INDEX,
+		schemaName: schemaName && schemaName !== "public" ? schemaName : void 0,
+		hashWhenTruncated: true
+	});
+}
+/**
+* Expression extracting the thread id embedded in a snapshot (jsonb columns only). Mirrors
+* the canonical extraction in `@mastra/core` (`getSnapshotMemoryInfo`), which reads one of
+* two layouts:
+* 1. agentic-loop: `context.<suspended step>.suspendPayload.__streamState.messageList.memoryInfo.threadId`
+* 2. durable loop: `context.input.messageListState.memoryInfo.threadId`
+*
+* `jsonb_path_query_first(jsonb, jsonpath)` is IMMUTABLE, so the expression is valid in an
+* expression index. The WHERE clause in listWorkflowRuns() must use this exact expression
+* text so the planner can match it against the index. If the snapshot layout changes in
+* core, this expression must be updated in lockstep or it will wrongly exclude rows.
+*/
+const WORKFLOW_SNAPSHOT_THREAD_ID_EXPR = `COALESCE(jsonb_path_query_first(snapshot, '$.context.* ? (@.status == "suspended").suspendPayload.__streamState.messageList.memoryInfo.threadId') #>> '{}', snapshot #>> '{context,input,messageListState,memoryInfo,threadId}')`;
+/**
+* Expression index on the snapshot-embedded thread id so listWorkflowRuns() threadId filters
+* (Agent.listSuspendedRuns) can use an index instead of detoasting every snapshot.
+*/
+function workflowSnapshotThreadIdIndexSQL(indexName, schemaName) {
+	return `CREATE INDEX IF NOT EXISTS "${indexName}" ON ${getTableName({
+		indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+		schemaName: getSchemaName(schemaName)
+	})} ((${WORKFLOW_SNAPSHOT_THREAD_ID_EXPR}))`;
+}
 var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorage {
 	#db;
 	#schema;
@@ -22284,6 +22467,7 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 		}));
 		for (const idx of WorkflowsPG.getDefaultIndexDefs(schemaPrefix)) statements.push(generateIndexSQL(idx, schemaName));
 		statements.push(`${workflowSnapshotStatusIndexSQL(workflowSnapshotStatusIndexName(parsedSchema), schemaName)};`);
+		statements.push(`${workflowSnapshotThreadIdIndexSQL(workflowSnapshotThreadIdIndexName(parsedSchema), schemaName)};`);
 		return statements;
 	}
 	/**
@@ -22310,6 +22494,12 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 		} catch (error) {
 			this.logger?.warn?.(`Failed to create index ${indexName}:`, error);
 		}
+		const threadIdIndexName = workflowSnapshotThreadIdIndexName(this.#schema);
+		try {
+			await this.#db.createIndexFromStatement(threadIdIndexName, workflowSnapshotThreadIdIndexSQL(threadIdIndexName, this.#schema));
+		} catch (error) {
+			this.logger?.warn?.(`Failed to create index ${threadIdIndexName}:`, error);
+		}
 	}
 	async init() {
 		await this.#db.createTable({
@@ -22590,7 +22780,7 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			}, error);
 		}
 	}
-	async listWorkflowRuns({ workflowName, fromDate, toDate, perPage, page, resourceId, status } = {}) {
+	async listWorkflowRuns({ workflowName, fromDate, toDate, perPage, page, resourceId, threadId, status } = {}) {
 		try {
 			const conditions = [];
 			const values = [];
@@ -22611,6 +22801,11 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 				values.push(resourceId);
 				paramIndex++;
 			} else this.logger?.warn?.(`[${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
+			if (threadId) if (await this.#db.getColumnType(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, "snapshot") === "jsonb") {
+				conditions.push(`${WORKFLOW_SNAPSHOT_THREAD_ID_EXPR} = $${paramIndex}`);
+				values.push(threadId);
+				paramIndex++;
+			} else this.logger?.warn?.(`[${_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT}] snapshot column is not jsonb. Skipping threadId filter.`);
 			if (fromDate) {
 				conditions.push(`"createdAt" >= $${paramIndex}`);
 				values.push(fromDate);