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

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-pg
 description: Documentation for @mastra/pg. Use when working with @mastra/pg APIs, configuration, or implementation.
 metadata:
   package: "@mastra/pg"
-  version: "1.36.0-alpha.0"
+  version: "1.36.0-alpha.2"
 ---
 
 ## When to use
@@ -14,18 +14,11 @@ Use this skill whenever you are working with @mastra/pg to obtain the domain-spe
 
 Read the individual reference documents for detailed explanations and code examples.
 
-### Docs
-
-- [Workers](references/docs-deployment-workers.md) - Run Mastra workflow orchestration, schedules, and long-running background tasks in dedicated workers to keep API processes responsive under load.
-- [Semantic recall](references/docs-memory-semantic-recall.md) - Retrieve relevant messages from past Mastra conversations with semantic recall, vector search, embeddings, metadata filters, and configurable storage.
-- [Working memory](references/docs-memory-working-memory.md) - Persist user profiles, preferences, and application data with Mastra working memory using resource- or thread-scoped templates and storage adapters.
-- [Storage](references/docs-storage.md) - Configure Mastra storage to persist memory, workflow state, observability data, evals, schedules, and long-running agent state across restarts.
-
 ### Integrations
 
 - [ClickHouse Managed Postgres](references/integrations-databases-clickhouse-managed-postgres.md) - Store Mastra application data in ClickHouse Managed Postgres with PostgresStore and verified TLS.
 - [DynamoDB](references/integrations-databases-dynamodb.md) - Persist Mastra data in Amazon DynamoDB with a single-table ElectroDB design, configurable indexes, TTL support, credentials, and table initialization.
-- [Neon Postgres](references/integrations-databases-neon.md) - Connect Mastra to Neon Postgres with PostgresStore, pooled production connections, schema initialization, vector search, and Neon agent skills.
+- [Neon Postgres](references/integrations-databases-neon.md) - Connect Mastra to Neon Postgres with PostgresStore, pooled production connections, schema initialization, vector search, and Neon agent skills, and give agents Neon tools through Mastra Connect.
 - [PostgreSQL](references/integrations-databases-postgresql.md) - Persist Mastra application data in PostgreSQL with PostgresStore, configure connections and pools, initialize schemas, and enable observability.
 - [PG](references/integrations-vectors-pg.md) - Run pgvector similarity search inside PostgreSQL from Mastra with HNSW or IVFFlat indexing, metadata filtering, and direct connection pool access.
 
@@ -38,10 +31,6 @@ Read the individual reference documents for detailed explanations and code examp
 - [Chunking and embedding documents](references/reference-rag-chunking-and-embedding.md) - Chunk documents with MDocument, generate embeddings through the AI SDK, and prepare text and metadata for vector storage and RAG retrieval.
 - [Reference: Metadata filters](references/reference-rag-metadata-filters.md) - Mastra provides a unified metadata filtering syntax across all vector stores, based on MongoDB/Sift query syntax.
 - [RAG (Retrieval-Augmented Generation) in Mastra](references/reference-rag-overview.md) - RAG in Mastra helps you enhance LLM outputs by incorporating relevant context from your own data sources, improving accuracy and grounding responses in real information.
-- [Retrieval, semantic search, reranking](references/reference-rag-retrieval.md) - After storing embeddings, you need to retrieve relevant chunks to answer user queries.
-- [Storing embeddings in a vector database](references/reference-rag-vector-databases.md) - After generating embeddings, you need to store them in a database that supports vector similarity search.
-- [Reference: Composite storage](references/reference-storage-composite.md) - MastraCompositeStore can compose storage domains from different providers. Use it when you need different databases for different purposes.
-- [Reference: Storage retention (prune)](references/reference-storage-retention.md) - prune() deletes rows. It caps growth and is safe to run against large tables (batched, bounded, resumable, cancellable).
 - [Reference: createVectorQueryTool()](references/reference-tools-vector-query-tool.md) - The createVectorQueryTool() function creates a tool for semantic search over vector stores.
 
 

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,86 +1,86 @@
 {
-  "version": "1.36.0-alpha.0",
+  "version": "1.36.0-alpha.2",
   "package": "@mastra/pg",
   "exports": {
     "AgentsPG": {
       "types": "dist/storage/domains/agents/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 4366
+      "line": 4371
     },
     "BackgroundTasksPG": {
       "types": "dist/storage/domains/background-tasks/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 5297
+      "line": 5302
     },
     "BlobsPG": {
       "types": "dist/storage/domains/blobs/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 5688
+      "line": 5693
     },
     "ChannelsPG": {
       "types": "dist/storage/domains/channels/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 5790
+      "line": 5795
     },
     "DatasetsPG": {
       "types": "dist/storage/domains/datasets/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 6032
+      "line": 6037
     },
     "ExperimentsPG": {
       "types": "dist/storage/domains/experiments/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 7289
+      "line": 7294
     },
     "FavoritesPG": {
       "types": "dist/storage/domains/favorites/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 8261
+      "line": 8266
     },
     "KnowledgePG": {
       "types": "dist/storage/domains/knowledge/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 10139
+      "line": 10144
     },
     "MCPClientsPG": {
       "types": "dist/storage/domains/mcp-clients/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 10296
+      "line": 10301
     },
     "MCPServersPG": {
       "types": "dist/storage/domains/mcp-servers/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 10865
+      "line": 10870
     },
     "MemoryPG": {
       "types": "dist/storage/domains/memory/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 11653
+      "line": 11658
     },
     "NotificationsPG": {
       "types": "dist/storage/domains/notifications/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 14464
+      "line": 14469
     },
     "ObservabilityPG": {
       "types": "dist/storage/domains/observability/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 14886
+      "line": 14891
     },
     "ObservabilityStoragePostgresVNext": {
       "types": "dist/storage/domains/observability/v-next/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 21800
+      "line": 21810
     },
     "PGVECTOR_PROMPT": {
       "types": "dist/vector/prompt.d.ts",
       "implementation": "dist/index.js",
-      "line": 28464
+      "line": 28481
     },
     "PgFactoryStorage": {
       "types": "dist/storage/factory-storage.d.ts",
       "implementation": "dist/index.js",
-      "line": 27950
+      "line": 27967
     },
     "PgVector": {
       "types": "dist/vector/index.d.ts",
@@ -95,67 +95,67 @@
     "PostgresStore": {
       "types": "dist/storage/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 28165
+      "line": 28182
     },
     "PostgresStoreVNext": {
       "types": "dist/storage/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 28383
+      "line": 28400
     },
     "PromptBlocksPG": {
       "types": "dist/storage/domains/prompt-blocks/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 22242
+      "line": 22255
     },
     "SchedulesPG": {
       "types": "dist/storage/domains/schedules/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 22869
+      "line": 22882
     },
     "ScorerDefinitionsPG": {
       "types": "dist/storage/domains/scorer-definitions/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 23190
+      "line": 23203
     },
     "ScoresPG": {
       "types": "dist/storage/domains/scores/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 23813
+      "line": 23826
     },
     "SkillsPG": {
       "types": "dist/storage/domains/skills/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 24256
+      "line": 24269
     },
     "ThreadStatePG": {
       "types": "dist/storage/domains/thread-state/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 24947
+      "line": 24960
     },
     "ToolProviderConnectionsPG": {
       "types": "dist/storage/domains/tool-provider-connections/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 25121
+      "line": 25134
     },
     "WorkflowDefinitionsPG": {
       "types": "dist/storage/domains/workflow-definitions/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 25385
+      "line": 25398
     },
     "WorkflowsPG": {
       "types": "dist/storage/domains/workflows/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 25768
+      "line": 25781
     },
     "WorkspacesPG": {
       "types": "dist/storage/domains/workspaces/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 27050
+      "line": 27067
     },
     "exportSchemas": {
       "types": "dist/storage/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 28132
+      "line": 28149
     }
   },
   "modules": {}

package/dist/docs/references/integrations-databases-neon.md

@@ -6,6 +6,8 @@
 
 [Neon](https://neon.com) is a managed PostgreSQL service. Mastra connects to Neon through [`PostgresStore`](https://mastra.ai/integrations/databases/postgresql), which uses the Node.js `pg` driver. Neon doesn't require a separate Mastra storage package.
 
+You can also give an agent tools to manage Neon projects and branches, run SQL, and apply schema migrations through [Mastra Connect](#connect).
+
 ## Quickstart
 
 Create a Neon project, then copy its [pooled connection string](https://neon.com/docs/connect/connect-from-any-app) into `DATABASE_URL`.
@@ -219,4 +221,38 @@ const vector = new PgVector({
 })
 ```
 
-Setting `disableInit: true` prevents the runtime process from creating or changing the extension, tables and indexes.
+Setting `disableInit: true` prevents the runtime process from creating or changing the extension, tables and indexes.
+
+## Connect
+
+Before you start, complete the [Connect setup](https://mastra.ai/docs/mastra-platform/connect) to install `@mastra/connect` and configure your platform project.
+
+### Agent tools
+
+Give agents tools from Neon's hosted Model Context Protocol (MCP) server to manage projects and branches, run SQL, and plan and apply schema migrations in Neon.
+
+Connect an account with the `neon-mcp` provider ID. Run this command from the directory that contains your `.env` file:
+
+```bash
+mastra connect add neon-mcp
+```
+
+Then pass [`tools()`](https://mastra.ai/reference/connect/tools) to the agent and select the provider:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { tools } from '@mastra/connect'
+
+export const neonMcpAgent = new Agent({
+  id: 'neon-mcp-agent',
+  name: 'Neon agent',
+  instructions:
+    'You help people manage projects and branches, run SQL, and plan and apply schema migrations in Neon.',
+  model: '__GATEWAY_OPENAI_MODEL_LUNA__',
+  tools: tools({ providers: ['neon-mcp'] }),
+})
+```
+
+Mastra discovers Neon's tools from its MCP server when the agent runs. The available tools depend on the server and the connected account, not on your `@mastra/connect` version. Tool keys start with `neon-mcp_`.
+
+To see which tools Neon provides, read the [Neon MCP server](https://neon.com/docs/ai/neon-mcp-server) documentation. To require approval before a call runs, see [MCP providers](https://mastra.ai/reference/connect/tools) in the `tools()` reference.

package/dist/docs/references/integrations-databases-postgresql.md

@@ -243,6 +243,52 @@ const thread = await memoryStore?.getThreadById({ threadId: '...' })
 
 > **Warning:** If `init()` isn't called, tables won't be created and storage operations will fail silently or throw errors.
 
+### Managed PostgreSQL and connection poolers
+
+`PostgresStore` connects to managed PostgreSQL providers with the connection string they give you. No provider-specific package is required.
+
+`init()` runs all schema changes on a single connection, so it works through transaction-mode connection poolers such as PgBouncer. You can use the provider's pooled connection string and let Mastra create the schema on startup.
+
+#### Separate schema initialization
+
+If the runtime database role can't create tables or indexes, run `init()` once during deployment with a role that can:
+
+```typescript
+import { PostgresStore } from '@mastra/pg'
+
+const storage = new PostgresStore({
+  id: 'pg-storage-init',
+  connectionString: process.env.DATABASE_ADMIN_URL,
+})
+
+try {
+  await storage.init()
+  // Only needed if the application uses Knowledge
+  await storage.initKnowledge()
+} finally {
+  await storage.close()
+}
+```
+
+The runtime role needs read and write access to the tables this script creates. See [PostgreSQL privileges](https://www.postgresql.org/docs/current/ddl-priv.html).
+
+Then set `disableInit: true` on the runtime store so it skips schema creation:
+
+```typescript
+import { Mastra } from '@mastra/core'
+import { PostgresStore } from '@mastra/pg'
+
+export const mastra = new Mastra({
+  storage: new PostgresStore({
+    id: 'pg-storage',
+    connectionString: process.env.DATABASE_URL,
+    disableInit: true,
+  }),
+})
+```
+
+`disableInit: true` also makes explicit `init()` calls a no-op, so leave it off the store in the deployment script.
+
 ### Using an Existing Pool
 
 If you already have a `pg.Pool` in your application (e.g., shared with an ORM or for Row Level Security), you can pass it directly to `PostgresStore`:

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

@@ -49,7 +49,7 @@ export const agent = new Agent({
 
 **options.retainFullInput** (`boolean`): When true, the request input is processed exactly as supplied instead of being filtered against stored history. Use this when you assemble the input yourself and need the message sequence preserved. Stored history is still loaded underneath, and every input message that isn't already stored is saved to the thread, including few-shot examples. Can be set per call on memory.options or agent-wide in the memory constructor options.
 
-**options.semanticRecall** (`boolean | { topK: number; messageRange: number | { before: number; after: number }; scope?: 'thread' | 'resource' }`): Enable semantic search in message history. Can be a boolean or an object with configuration options. When enabled, requires a vector store, and an embedder unless the vector store embeds text itself (isSelfEmbedding). Default topK is 4, default messageRange is {before: 1, after: 1}.
+**options.semanticRecall** (`boolean | { topK: number; messageRange: number | { before: number; after: number }; scope?: 'thread' | 'resource'; maxChunkChars?: number }`): Enable semantic search in message history. Can be a boolean or an object with configuration options. When enabled, requires a vector store, and an embedder unless the vector store embeds text itself (isSelfEmbedding). Default topK is 4, default messageRange is {before: 1, after: 1}. maxChunkChars caps the characters of message text per embedded chunk; see Long messages.
 
 **options.workingMemory** (`WorkingMemory`): Configuration for working memory feature. Can be { enabled: boolean; template?: string; schema?: ZodObject\<any> | JSONSchema7; scope?: 'thread' | 'resource' } or { enabled: boolean } to disable.
 

package/dist/docs/references/reference-processors-semantic-recall-processor.md

@@ -44,6 +44,8 @@ const processor = new SemanticRecall({
 
 **options.logger** (`IMastraLogger`): Optional logger instance for structured logging
 
+**options.maxChunkChars** (`number`): Largest number of characters of message text sent to the embedder in one input. Longer messages are split into chunks, each stored as its own vector row. When unset, the limit comes from the embedder's maxInputTokens if it declares one (FastEmbed models do), otherwise 16,384 characters (about 4,096 English tokens).
+
 ## Returns
 
 **id** (`string`): Processor identifier set to 'semantic-recall'
@@ -105,9 +107,9 @@ export const agent = new Agent({
 
 ### Output processing
 
-1. Extracts text content from new user and assistant messages
-2. Generates embeddings for each message
-3. Stores embeddings in the vector store with metadata (message ID, thread ID, resource ID, role, content, timestamp)
+1. Extracts text content from new user and assistant messages, skipping messages already embedded earlier in the same run
+2. Splits long messages into chunks of at most `maxChunkChars` characters and generates an embedding for each chunk
+3. Stores one vector row per chunk with metadata (thread metadata, message ID, thread ID, resource ID, role, content, timestamp). Row IDs are derived from the message ID (the first chunk uses a UUID message ID as is), so saving the same message again replaces its rows instead of adding new ones
 4. Uses LRU caching for embeddings to avoid redundant API calls
 
 ### Cross-thread recall

package/dist/index.cjs

@@ -2719,7 +2719,8 @@ async function loadSchemaSnapshot(client, schemaName) {
 		notNullColumns,
 		indexes,
 		replicaIdentityIndexes,
-		primaryKeyIndexes
+		primaryKeyIndexes,
+		createdTables: /* @__PURE__ */ new Set()
 	};
 }
 // src/storage/db/index.ts
@@ -2879,26 +2880,30 @@ function generateTableSQL({ tableName, schema, schemaName, compositePrimaryKey,
             ` : ""}
           `;
 }
+function indexColumnsSQL(columns, opclass) {
+	return columns.map((col) => {
+		const [colName, ...modifiers] = col.includes(" DESC") || col.includes(" ASC") ? col.split(" ") : [col];
+		if (!colName) throw new Error(`Invalid column specification: ${col}`);
+		return [
+			`"${(0, _mastra_core_utils.parseSqlIdentifier)(colName, "column name")}"`,
+			opclass,
+			...modifiers
+		].filter(Boolean).join(" ");
+	}).join(", ");
+}
 /**
 * Generates a CREATE INDEX SQL statement from index options.
 * Used by exportSchemas to produce index DDL without a database connection.
 */
 function generateIndexSQL(options, schemaName) {
-	const { name, table, columns, unique = false, where, method = "btree" } = options;
+	const { name, table, columns, unique = false, where, method = "btree", opclass } = options;
 	const fullTableName = getTableName$6({
 		indexName: table,
 		schemaName: getSchemaName$6(schemaName)
 	});
 	const uniqueStr = unique ? "UNIQUE " : "";
 	const methodStr = method !== "btree" ? `USING ${method} ` : "";
-	const columnsStr = columns.map((col) => {
-		if (col.includes(" DESC") || col.includes(" ASC")) {
-			const [colName, ...modifiers] = col.split(" ");
-			if (!colName) throw new Error(`Invalid column specification: ${col}`);
-			return `"${(0, _mastra_core_utils.parseSqlIdentifier)(colName, "column name")}" ${modifiers.join(" ")}`;
-		}
-		return `"${(0, _mastra_core_utils.parseSqlIdentifier)(col, "column name")}"`;
-	}).join(", ");
+	const columnsStr = indexColumnsSQL(columns, opclass);
 	const whereStr = where ? ` WHERE ${where}` : "";
 	return `CREATE ${uniqueStr}INDEX IF NOT EXISTS ${`"${(0, _mastra_core_utils.parseSqlIdentifier)(name, "index name")}"`} ON ${fullTableName} ${methodStr}(${columnsStr})${whereStr};`;
 }
@@ -3409,6 +3414,7 @@ var PgDB = class extends _mastra_core_base.MastraBase {
 			if (this.schemaName) await this.setupSchema();
 			const snapshot = this.schemaSnapshot;
 			if (!snapshot || !this.snapshotShowsTableConverged(snapshot, tableName)) {
+				const isNewTable = snapshot ? !snapshot.tables.has(tableName) : false;
 				const sql = generateTableSQL({
 					tableName,
 					schema,
@@ -3422,6 +3428,7 @@ var PgDB = class extends _mastra_core_base.MastraBase {
 				}
 				if (snapshot) {
 					snapshot.tables.add(tableName);
+					if (isNewTable) snapshot.createdTables.add(tableName);
 					const created = this.snapshotColumns(snapshot, tableName);
 					for (const [name, def] of Object.entries(schema)) {
 						const parsedName = (0, _mastra_core_utils.parseSqlIdentifier)(name, "column name");
@@ -3890,18 +3897,9 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			const snapshot = this.schemaSnapshot;
 			if (snapshot?.indexes.has(name)) return;
 			const uniqueStr = unique ? "UNIQUE " : "";
-			const concurrentStr = concurrent ? "CONCURRENTLY " : "";
+			const concurrentStr = concurrent && !this.isTableCreatedInThisInit(table) ? "CONCURRENTLY " : "";
 			const methodStr = method !== "btree" ? `USING ${method} ` : "";
-			const columnsStr = columns.map((col) => {
-				if (col.includes(" DESC") || col.includes(" ASC")) {
-					const [colName, ...modifiers] = col.split(" ");
-					if (!colName) throw new Error(`Invalid column specification: ${col}`);
-					const quotedCol = `"${(0, _mastra_core_utils.parseSqlIdentifier)(colName, "column name")}" ${modifiers.join(" ")}`;
-					return opclass ? `${quotedCol} ${opclass}` : quotedCol;
-				}
-				const quotedCol = `"${(0, _mastra_core_utils.parseSqlIdentifier)(col, "column name")}"`;
-				return opclass ? `${quotedCol} ${opclass}` : quotedCol;
-			}).join(", ");
+			const columnsStr = indexColumnsSQL(columns, opclass);
 			const whereStr = where ? ` WHERE ${where}` : "";
 			const tablespaceStr = tablespace ? ` TABLESPACE ${tablespace}` : "";
 			let withStr = "";
@@ -3934,6 +3932,13 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 		if (snapshot?.indexes.has(indexName)) return;
 		if (await buildIndex(this.client, this.schemaName || "public", indexName, () => this.timedIndexBuild(indexName, sql), this.logger)) snapshot?.indexes.add(indexName);
 	}
+	/**
+	* Whether `tableName` was absent when this init's snapshot was read and this
+	* init created it, so its indexes can be built without CONCURRENTLY.
+	*/
+	isTableCreatedInThisInit(tableName) {
+		return this.schemaSnapshot?.createdTables.has(tableName) ?? false;
+	}
 	async timedIndexBuild(indexName, sql) {
 		const startedAt = Date.now();
 		this.logger.info(`Creating index ${indexName}`);
@@ -18337,6 +18342,11 @@ async function batchCreateFeedback(client, schema, args, partitioning) {
 	const rows = [...new Map(args.feedbacks.map((feedback) => [feedback.feedbackId, feedback])).values()].map(feedbackRecordToRow);
 	await insertRows(client, schema, TABLE_FEEDBACK_EVENTS, rows, partitioning, FEEDBACK_UPSERT_CLAUSE);
 }
+async function getFeedbackById(client, schema, feedbackId) {
+	const row = await client.oneOrNone(`SELECT ${FEEDBACK_SELECT_COLUMNS} FROM ${qualifiedTable(schema, TABLE_FEEDBACK_EVENTS)}
+     WHERE "feedbackId" = $1 ORDER BY "cursorId" DESC LIMIT 1`, [feedbackId]);
+	return row ? rowToFeedbackRecord(row) : null;
+}
 async function updateFeedbackReviewStatus(client, schema, args) {
 	const { feedbackId, reviewStatus } = parseUpdateFeedbackReviewStatusArgs(args);
 	const row = await client.oneOrNone(`UPDATE ${qualifiedTable(schema, TABLE_FEEDBACK_EVENTS)}
@@ -22172,6 +22182,9 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 	async getScoreById(scoreId) {
 		return this.#run("GET_SCORE_BY_ID", () => getScoreById(this.#readClient, this.#schema, scoreId), { scoreId });
 	}
+	async getFeedbackById(feedbackId) {
+		return this.#run("GET_FEEDBACK_BY_ID", () => getFeedbackById(this.#readClient, this.#schema, feedbackId), { feedbackId });
+	}
 	async listFeedback(args) {
 		return this.#run("LIST_FEEDBACK", () => listFeedback(this.#readClient, this.#schema, args));
 	}
@@ -25956,15 +25969,16 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			this.logger?.warn?.(`Failed to create index ${stateBaseIndexName}:`, error);
 		}
 		if (await this.#db.getColumnType(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, "snapshot") !== "jsonb") return;
+		const concurrently = !this.#db.isTableCreatedInThisInit(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT);
 		const indexName = workflowSnapshotStatusIndexName(this.#schema);
 		try {
-			await this.#db.createIndexFromStatement(indexName, workflowSnapshotStatusIndexSQL(indexName, this.#schema, true));
+			await this.#db.createIndexFromStatement(indexName, workflowSnapshotStatusIndexSQL(indexName, this.#schema, concurrently));
 		} 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, true));
+			await this.#db.createIndexFromStatement(threadIdIndexName, workflowSnapshotThreadIdIndexSQL(threadIdIndexName, this.#schema, concurrently));
 		} catch (error) {
 			this.logger?.warn?.(`Failed to create index ${threadIdIndexName}:`, error);
 		}
@@ -27012,18 +27026,9 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			}
 			const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
 			const v2WhereClause = v2Conditions.length > 0 ? `WHERE ${v2Conditions.join(" AND ")}` : "";
-			let total = 0;
 			const usePagination = typeof perPage === "number" && typeof page === "number";
-			if (usePagination) {
-				const countResult = await this.#db.client.one(`SELECT (SELECT COUNT(*) FROM ${getTableName({
-					indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
-					schemaName: getSchemaName(this.#schema)
-				})} ${whereClause})
-             + (SELECT COUNT(*) FROM ${this.#runsTable()} ${v2WhereClause}) AS count`, values);
-				total = Number(countResult.count);
-			}
 			const normalizedPerPage = usePagination ? (0, _mastra_core_storage.normalizePerPage)(perPage, Number.MAX_SAFE_INTEGER) : 0;
-			const offset = usePagination ? page * normalizedPerPage : void 0;
+			const offset = usePagination ? page * normalizedPerPage : 0;
 			let v1Snapshot = "snapshot";
 			if (summary) {
 				const snapshotJson = await this.#db.getColumnType(_mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT, "snapshot") === "jsonb" ? "snapshot" : `regexp_replace(snapshot::text, '\\\\u(0000|[Dd][89A-Fa-f][0-9A-Fa-f]{2})', '', 'g')::jsonb`;
@@ -27043,6 +27048,18 @@ var WorkflowsPG = class WorkflowsPG extends _mastra_core_storage.WorkflowsStorag
 			] : values;
 			const result = await this.#db.client.manyOrNone(query, queryValues);
 			const runs = await Promise.all((result || []).map((row) => this.#parseRun(this.#db.client, row)));
+			let total = 0;
+			if (usePagination) {
+				total = offset + runs.length;
+				if (runs.length === normalizedPerPage || runs.length === 0 && offset > 0) {
+					const countResult = await this.#db.client.one(`SELECT (SELECT COUNT(*) FROM ${getTableName({
+						indexName: _mastra_core_storage.TABLE_WORKFLOW_SNAPSHOT,
+						schemaName: getSchemaName(this.#schema)
+					})} ${whereClause})
+               + (SELECT COUNT(*) FROM ${this.#runsTable()} ${v2WhereClause}) AS count`, values);
+					total = Number(countResult.count);
+				}
+			}
 			return {
 				runs,
 				total: total || runs.length