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

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.1"
 ---
 
 ## 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,5 +1,5 @@
 {
-  "version": "1.36.0-alpha.0",
+  "version": "1.36.0-alpha.1",
   "package": "@mastra/pg",
   "exports": {
     "AgentsPG": {
@@ -70,17 +70,17 @@
     "ObservabilityStoragePostgresVNext": {
       "types": "dist/storage/domains/observability/v-next/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 21800
+      "line": 21805
     },
     "PGVECTOR_PROMPT": {
       "types": "dist/vector/prompt.d.ts",
       "implementation": "dist/index.js",
-      "line": 28464
+      "line": 28475
     },
     "PgFactoryStorage": {
       "types": "dist/storage/factory-storage.d.ts",
       "implementation": "dist/index.js",
-      "line": 27950
+      "line": 27961
     },
     "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": 28176
     },
     "PostgresStoreVNext": {
       "types": "dist/storage/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 28383
+      "line": 28394
     },
     "PromptBlocksPG": {
       "types": "dist/storage/domains/prompt-blocks/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 22242
+      "line": 22250
     },
     "SchedulesPG": {
       "types": "dist/storage/domains/schedules/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 22869
+      "line": 22877
     },
     "ScorerDefinitionsPG": {
       "types": "dist/storage/domains/scorer-definitions/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 23190
+      "line": 23198
     },
     "ScoresPG": {
       "types": "dist/storage/domains/scores/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 23813
+      "line": 23821
     },
     "SkillsPG": {
       "types": "dist/storage/domains/skills/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 24256
+      "line": 24264
     },
     "ThreadStatePG": {
       "types": "dist/storage/domains/thread-state/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 24947
+      "line": 24955
     },
     "ToolProviderConnectionsPG": {
       "types": "dist/storage/domains/tool-provider-connections/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 25121
+      "line": 25129
     },
     "WorkflowDefinitionsPG": {
       "types": "dist/storage/domains/workflow-definitions/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 25385
+      "line": 25393
     },
     "WorkflowsPG": {
       "types": "dist/storage/domains/workflows/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 25768
+      "line": 25776
     },
     "WorkspacesPG": {
       "types": "dist/storage/domains/workspaces/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 27050
+      "line": 27061
     },
     "exportSchemas": {
       "types": "dist/storage/index.d.ts",
       "implementation": "dist/index.js",
-      "line": 28132
+      "line": 28143
     }
   },
   "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/index.cjs

@@ -18337,6 +18337,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 +22177,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));
 	}
@@ -27012,18 +27020,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 +27042,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