@mastra/pg 1.0.0 → 1.1.0-alpha.0

package/dist/docs/rag/02-vector-databases.md

@@ -376,7 +376,7 @@ The dimension size must match the output dimension of your chosen embedding mode
 
 - OpenAI text-embedding-3-small: 1536 dimensions (or custom, e.g., 256)
 - Cohere embed-multilingual-v3: 1024 dimensions
-- Google text-embedding-004: 768 dimensions (or custom)
+- Google gemini-embedding-001: 768 dimensions (or custom)
 
 > **Note:**
 Index dimensions cannot be changed after creation. To use a different model, delete and recreate the index with the new dimension size.

package/dist/docs/rag/03-retrieval.md

@@ -73,7 +73,7 @@ Filter results based on metadata fields to narrow down the search space. This ap
 
 This is useful when you have documents from different sources, time periods, or with specific attributes. Mastra provides a unified MongoDB-style query syntax that works across all supported vector stores.
 
-For detailed information about available operators and syntax, see the [Metadata Filters Reference](https://mastra.ai/reference/v1/rag/metadata-filters).
+For detailed information about available operators and syntax, see the [Metadata Filters Reference](https://mastra.ai/reference/rag/metadata-filters).
 
 Basic filtering examples:
 
@@ -264,7 +264,7 @@ await pineconeQueryTool.execute(
 );
 ```
 
-For detailed configuration options and advanced usage, see the [Vector Query Tool Reference](https://mastra.ai/reference/v1/tools/vector-query-tool).
+For detailed configuration options and advanced usage, see the [Vector Query Tool Reference](https://mastra.ai/reference/tools/vector-query-tool).
 
 ### Vector Store Prompts
 
@@ -543,6 +543,6 @@ const relevanceProvider = new ZeroEntropyRelevanceScorer("zerank-1");
 
 The re-ranked results combine vector similarity with semantic understanding to improve retrieval quality.
 
-For more details about re-ranking, see the [rerank()](https://mastra.ai/reference/v1/rag/rerankWithScorer) method.
+For more details about re-ranking, see the [rerank()](https://mastra.ai/reference/rag/rerankWithScorer) method.
 
-For graph-based retrieval that follows connections between chunks, see the [GraphRAG](https://mastra.ai/docs/v1/rag/graph-rag) documentation.
+For graph-based retrieval that follows connections between chunks, see the [GraphRAG](https://mastra.ai/docs/rag/graph-rag) documentation.

package/dist/docs/rag/04-reference.md

@@ -357,13 +357,13 @@ const results = await store.query({
 
 ## Related
 
-- [Astra](https://mastra.ai/reference/v1/vectors/astra)
-- [Chroma](https://mastra.ai/reference/v1/vectors/chroma)
-- [Cloudflare Vectorize](https://mastra.ai/reference/v1/vectors/vectorize)
-- [libSQL](https://mastra.ai/reference/v1/vectors/libsql)
-- [MongoDB](https://mastra.ai/reference/v1/vectors/mongodb)
-- [PgStore](https://mastra.ai/reference/v1/vectors/pg)
-- [Pinecone](https://mastra.ai/reference/v1/vectors/pinecone)
-- [Qdrant](https://mastra.ai/reference/v1/vectors/qdrant)
-- [Upstash](https://mastra.ai/reference/v1/vectors/upstash)
-- [Amazon S3 Vectors](https://mastra.ai/reference/v1/vectors/s3vectors)
+- [Astra](https://mastra.ai/reference/vectors/astra)
+- [Chroma](https://mastra.ai/reference/vectors/chroma)
+- [Cloudflare Vectorize](https://mastra.ai/reference/vectors/vectorize)
+- [libSQL](https://mastra.ai/reference/vectors/libsql)
+- [MongoDB](https://mastra.ai/reference/vectors/mongodb)
+- [PgStore](https://mastra.ai/reference/vectors/pg)
+- [Pinecone](https://mastra.ai/reference/vectors/pinecone)
+- [Qdrant](https://mastra.ai/reference/vectors/qdrant)
+- [Upstash](https://mastra.ai/reference/vectors/upstash)
+- [Amazon S3 Vectors](https://mastra.ai/reference/vectors/s3vectors)

package/dist/docs/storage/01-reference.md

@@ -15,14 +15,14 @@
 
 `MastraCompositeStore` is included in `@mastra/core`:
 
-```bash
-npm install @mastra/core@beta
+```bash npm2yarn
+npm install @mastra/core@latest
 ```
 
 You'll also need to install the storage providers you want to compose:
 
-```bash
-npm install @mastra/pg@beta @mastra/libsql@beta
+```bash npm2yarn
+npm install @mastra/pg@latest @mastra/libsql@latest
 ```
 
 ## Storage domains
@@ -159,7 +159,9 @@ const storage = new MastraCompositeStore({
 
 ### Specialized storage for observability
 
-Use a time-series database for traces while keeping other data in PostgreSQL:
+Observability data can quickly overwhelm general-purpose databases in production. A single agent interaction can generate hundreds of spans, and high-traffic applications can produce thousands of traces per day.
+
+**ClickHouse** is recommended for production observability because it's optimized for high-volume, write-heavy analytics workloads. Use composite storage to route observability to ClickHouse while keeping other data in your primary database:
 
 ```typescript
 import { MastraCompositeStore } from "@mastra/core/storage";
@@ -181,6 +183,10 @@ const storage = new MastraCompositeStore({
 });
 ```
 
+> **Note:**
+
+This approach is also required when using storage providers that don't support observability (like Convex, DynamoDB, or Cloudflare). See the [DefaultExporter documentation](https://mastra.ai/docs/observability/tracing/exporters/default#storage-provider-support) for the full list of supported providers.
+
 ---
 
 ## Reference: DynamoDB Storage
@@ -189,24 +195,26 @@ const storage = new MastraCompositeStore({
 
 The DynamoDB storage implementation provides a scalable and performant NoSQL database solution for Mastra, leveraging a single-table design pattern with [ElectroDB](https://electrodb.dev/).
 
+> **Observability Not Supported**
+DynamoDB storage **does not support the observability domain**. Traces from the `DefaultExporter` cannot be persisted to DynamoDB, and Mastra Studio's observability features won't work with DynamoDB as your only storage provider. To enable observability, use [composite storage](https://mastra.ai/reference/storage/composite#specialized-storage-for-observability) to route observability data to a supported provider like ClickHouse or PostgreSQL.
+
+> **Item Size Limit**
+DynamoDB enforces a **400 KB maximum item size**. This limit can be exceeded when storing messages with base64-encoded attachments such as images. See [Handling large attachments](https://mastra.ai/docs/memory/storage#handling-large-attachments) for workarounds including uploading attachments to external storage.
+
 ## Features
 
 - Efficient single-table design for all Mastra storage needs
 - Based on ElectroDB for type-safe DynamoDB access
 - Support for AWS credentials, regions, and endpoints
 - Compatible with AWS DynamoDB Local for development
-- Stores Thread, Message, Trace, Eval, and Workflow data
+- Stores Thread, Message, Eval, and Workflow data
 - Optimized for serverless environments
 - Configurable TTL (Time To Live) for automatic data expiration per entity type
 
 ## Installation
 
-```bash
-npm install @mastra/dynamodb@beta
-# or
-pnpm add @mastra/dynamodb@beta
-# or
-yarn add @mastra/dynamodb@beta
+```bash npm2yarn
+npm install @mastra/dynamodb@latest
 ```
 
 ## Prerequisites
@@ -440,8 +448,8 @@ The PostgreSQL storage implementation provides a production-ready storage soluti
 
 ## Installation
 
-```bash
-npm install @mastra/pg@beta
+```bash npm2yarn
+npm install @mastra/pg@latest
 ```
 
 ## Usage
@@ -463,22 +471,26 @@ You can instantiate `PostgresStore` in the following ways:
 
 ```ts
 import { PostgresStore } from "@mastra/pg";
+import { Pool } from "pg";
 
-// Using a connection string only
+// Using a connection string
 const store1 = new PostgresStore({
   id: 'pg-storage-1',
   connectionString: "postgresql://user:password@localhost:5432/mydb",
 });
 
-// Using a connection string with a custom schema name
+// Using a connection string with pool options
 const store2 = new PostgresStore({
   id: 'pg-storage-2',
   connectionString: "postgresql://user:password@localhost:5432/mydb",
-  schemaName: "custom_schema", // optional
+  schemaName: "custom_schema",
+  max: 30,                    // Max pool connections
+  idleTimeoutMillis: 60000,   // Idle timeout
+  ssl: { rejectUnauthorized: false },
 });
 
 // Using individual connection parameters
-const store4 = new PostgresStore({
+const store3 = new PostgresStore({
   id: 'pg-storage-3',
   host: "localhost",
   port: 5432,
@@ -487,14 +499,16 @@ const store4 = new PostgresStore({
   password: "password",
 });
 
-// Individual parameters with schemaName
-const store5 = new PostgresStore({
+// Using a pre-configured pg.Pool (recommended for pool reuse)
+const existingPool = new Pool({
+  connectionString: "postgresql://user:password@localhost:5432/mydb",
+  max: 20,
+  // ... your custom pool configuration
+});
+
+const store4 = new PostgresStore({
   id: 'pg-storage-4',
-  host: "localhost",
-  port: 5432,
-  database: "mydb",
-  user: "user",
-  password: "password",
+  pool: existingPool,
   schemaName: "custom_schema", // optional
 });
 ```
@@ -513,6 +527,14 @@ The storage implementation handles schema creation and updates automatically. It
 - `mastra_scorers`: Stores scoring and evaluation data
 - `mastra_resources`: Stores resource working memory data
 
+### Observability
+
+PostgreSQL supports observability and can handle low trace volumes. Throughput capacity depends on deployment factors such as hardware, schema design, indexing, and retention policies, and should be validated for your specific environment. For high-volume production environments, consider:
+
+- Using the `insert-only` [tracing strategy](https://mastra.ai/docs/observability/tracing/exporters/default#tracing-strategies) to reduce database write operations
+- Setting up table partitioning for efficient data retention
+- Migrating observability to [ClickHouse via composite storage](https://mastra.ai/reference/storage/composite#specialized-storage-for-observability) if you need to scale further
+
 ### Initialization
 
 When you pass storage to the Mastra class, `init()` is called automatically before any storage operation:
@@ -552,19 +574,74 @@ const thread = await memoryStore?.getThreadById({ threadId: "..." });
 > **Note:**
 If `init()` is not called, tables won't be created and storage operations will fail silently or throw errors.
 
+### 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`:
+
+```typescript
+import { Pool } from "pg";
+import { PostgresStore } from "@mastra/pg";
+
+// Your existing pool (shared across your application)
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+  max: 20,
+});
+
+const storage = new PostgresStore({
+  id: "shared-storage",
+  pool: pool,
+});
+```
+
+**Pool lifecycle behavior:**
+
+- When you **provide a pool**: Mastra uses your pool but does **not** close it when `store.close()` is called. You manage the pool lifecycle.
+- When Mastra **creates a pool**: Mastra owns the pool and will close it when `store.close()` is called.
+
 ### Direct Database and Pool Access
 
-`PostgresStore` exposes both the underlying database object and the pg-promise instance as public fields:
+`PostgresStore` exposes the underlying database client and pool for advanced use cases:
+
+```typescript
+store.db;   // DbClient - query interface with helpers (any, one, tx, etc.)
+store.pool; // pg.Pool - the underlying connection pool
+```
+
+**Using `store.db` for queries:**
 
 ```typescript
-store.db; // pg-promise database instance
-store.pgp; // pg-promise main instance
+// Execute queries with helper methods
+const users = await store.db.any("SELECT * FROM users WHERE active = $1", [true]);
+const user = await store.db.one("SELECT * FROM users WHERE id = $1", [userId]);
+const maybeUser = await store.db.oneOrNone("SELECT * FROM users WHERE email = $1", [email]);
+
+// Use transactions
+const result = await store.db.tx(async (t) => {
+  await t.none("INSERT INTO logs (message) VALUES ($1)", ["Started"]);
+  const data = await t.any("SELECT * FROM items");
+  return data;
+});
+```
+
+**Using `store.pool` directly:**
+
+```typescript
+// Get a client for manual connection management
+const client = await store.pool.connect();
+try {
+  await client.query("SET LOCAL app.user_id = $1", [userId]);
+  const result = await client.query("SELECT * FROM protected_table");
+  return result.rows;
+} finally {
+  client.release();
+}
 ```
 
-This enables direct queries and custom transaction management. When using these fields:
+When using these fields:
 
 - You are responsible for proper connection and transaction handling.
-- Closing the store (`store.close()`) will destroy the associated connection pool.
+- Closing the store (`store.close()`) will destroy the pool only if Mastra created it.
 - Direct access bypasses any additional logic or validation provided by PostgresStore methods.
 
 This approach is intended for advanced scenarios where low-level access is required.

package/dist/docs/tools/01-reference.md

@@ -340,8 +340,8 @@ const response = await agent.generate(
 
 For more information on request context, please see:
 
-- [Agent Request Context](https://mastra.ai/docs/v1/server/request-context)
-- [Request Context](https://mastra.ai/docs/v1/server/request-context#accessing-values-with-tools)
+- [Agent Request Context](https://mastra.ai/docs/server/request-context)
+- [Request Context](https://mastra.ai/docs/server/request-context#accessing-values-with-tools)
 
 ## Usage Without a Mastra Server
 

package/dist/docs/vectors/01-reference.md

@@ -263,8 +263,8 @@ Embeddings are numeric vectors used by memory's `semanticRecall` to retrieve rel
 
 Install `fastembed` to get started:
 
-```bash
-npm install @mastra/fastembed@beta
+```bash npm2yarn
+npm install @mastra/fastembed@latest
 ```
 
 Add the following to your agent:

package/dist/index.cjs

@@ -3117,7 +3117,7 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
   #skipDefaultIndexes;
   #indexes;
   /** Tables managed by this domain */
-  static MANAGED_TABLES = [storage.TABLE_AGENTS];
+  static MANAGED_TABLES = [storage.TABLE_AGENTS, storage.TABLE_AGENT_VERSIONS];
   constructor(config) {
     super();
     const { client, schemaName, skipDefaultIndexes, indexes } = resolvePgConfig(config);
@@ -3144,6 +3144,7 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
   }
   async init() {
     await this.#db.createTable({ tableName: storage.TABLE_AGENTS, schema: storage.TABLE_SCHEMAS[storage.TABLE_AGENTS] });
+    await this.#db.createTable({ tableName: storage.TABLE_AGENT_VERSIONS, schema: storage.TABLE_SCHEMAS[storage.TABLE_AGENT_VERSIONS] });
     await this.createDefaultIndexes();
     await this.createCustomIndexes();
   }
@@ -3163,6 +3164,7 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
     }
   }
   async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_AGENT_VERSIONS });
     await this.#db.clearTable({ tableName: storage.TABLE_AGENTS });
   }
   parseJson(value, fieldName) {
@@ -3200,11 +3202,14 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
       defaultOptions: this.parseJson(row.defaultOptions, "defaultOptions"),
       workflows: this.parseJson(row.workflows, "workflows"),
       agents: this.parseJson(row.agents, "agents"),
+      integrationTools: this.parseJson(row.integrationTools, "integrationTools"),
       inputProcessors: this.parseJson(row.inputProcessors, "inputProcessors"),
       outputProcessors: this.parseJson(row.outputProcessors, "outputProcessors"),
       memory: this.parseJson(row.memory, "memory"),
       scorers: this.parseJson(row.scorers, "scorers"),
       metadata: this.parseJson(row.metadata, "metadata"),
+      ownerId: row.ownerId,
+      activeVersionId: row.activeVersionId,
       createdAt: row.createdAtZ || row.createdAt,
       updatedAt: row.updatedAtZ || row.updatedAt
     };
@@ -3236,10 +3241,12 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
       const nowIso = now.toISOString();
       await this.#db.client.none(
         `INSERT INTO ${tableName} (
-          id, name, description, instructions, model, tools, 
-          "defaultOptions", workflows, agents, "inputProcessors", "outputProcessors", memory, scorers, metadata, 
+          id, name, description, instructions, model, tools,
+          "defaultOptions", workflows, agents, "integrationTools",
+          "inputProcessors", "outputProcessors", memory, scorers, metadata,
+          "ownerId", "activeVersionId",
           "createdAt", "createdAtZ", "updatedAt", "updatedAtZ"
-        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18)`,
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21)`,
         [
           agent.id,
           agent.name,
@@ -3250,11 +3257,14 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
           agent.defaultOptions ? JSON.stringify(agent.defaultOptions) : null,
           agent.workflows ? JSON.stringify(agent.workflows) : null,
           agent.agents ? JSON.stringify(agent.agents) : null,
+          agent.integrationTools ? JSON.stringify(agent.integrationTools) : null,
           agent.inputProcessors ? JSON.stringify(agent.inputProcessors) : null,
           agent.outputProcessors ? JSON.stringify(agent.outputProcessors) : null,
           agent.memory ? JSON.stringify(agent.memory) : null,
           agent.scorers ? JSON.stringify(agent.scorers) : null,
           agent.metadata ? JSON.stringify(agent.metadata) : null,
+          agent.ownerId ?? null,
+          agent.activeVersionId ?? null,
           nowIso,
           nowIso,
           nowIso,
@@ -3342,6 +3352,18 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
         setClauses.push(`scorers = $${paramIndex++}`);
         values.push(JSON.stringify(updates.scorers));
       }
+      if (updates.integrationTools !== void 0) {
+        setClauses.push(`"integrationTools" = $${paramIndex++}`);
+        values.push(JSON.stringify(updates.integrationTools));
+      }
+      if (updates.ownerId !== void 0) {
+        setClauses.push(`"ownerId" = $${paramIndex++}`);
+        values.push(updates.ownerId);
+      }
+      if (updates.activeVersionId !== void 0) {
+        setClauses.push(`"activeVersionId" = $${paramIndex++}`);
+        values.push(updates.activeVersionId);
+      }
       if (updates.metadata !== void 0) {
         const mergedMetadata = { ...existingAgent.metadata, ...updates.metadata };
         setClauses.push(`metadata = $${paramIndex++}`);
@@ -3388,6 +3410,7 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
   async deleteAgent({ id }) {
     try {
       const tableName = getTableName2({ indexName: storage.TABLE_AGENTS, schemaName: getSchemaName2(this.#schema) });
+      await this.deleteVersionsByAgentId(id);
       await this.#db.client.none(`DELETE FROM ${tableName} WHERE id = $1`, [id]);
     } catch (error$1) {
       throw new error.MastraError(
@@ -3454,6 +3477,234 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
       );
     }
   }
+  // ==========================================================================
+  // Agent Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      await this.#db.client.none(
+        `INSERT INTO ${tableName} (
+          id, "agentId", "versionNumber", name, snapshot, "changedFields", "changeMessage", "createdAt", "createdAtZ"
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
+        [
+          input.id,
+          input.agentId,
+          input.versionNumber,
+          input.name ?? null,
+          JSON.stringify(input.snapshot),
+          input.changedFields ? JSON.stringify(input.changedFields) : null,
+          input.changeMessage ?? null,
+          nowIso,
+          nowIso
+        ]
+      );
+      return {
+        ...input,
+        createdAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "CREATE_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: input.id, agentId: input.agentId }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersion(id) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const result = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE id = $1`, [id]);
+      if (!result) {
+        return null;
+      }
+      return this.parseVersionRow(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "GET_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersionByNumber(agentId, versionNumber) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const result = await this.#db.client.oneOrNone(
+        `SELECT * FROM ${tableName} WHERE "agentId" = $1 AND "versionNumber" = $2`,
+        [agentId, versionNumber]
+      );
+      if (!result) {
+        return null;
+      }
+      return this.parseVersionRow(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "GET_VERSION_BY_NUMBER", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId, versionNumber }
+        },
+        error$1
+      );
+    }
+  }
+  async getLatestVersion(agentId) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const result = await this.#db.client.oneOrNone(
+        `SELECT * FROM ${tableName} WHERE "agentId" = $1 ORDER BY "versionNumber" DESC LIMIT 1`,
+        [agentId]
+      );
+      if (!result) {
+        return null;
+      }
+      return this.parseVersionRow(result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "GET_LATEST_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error$1
+      );
+    }
+  }
+  async listVersions(input) {
+    const { agentId, page = 0, perPage: perPageInput, orderBy } = input;
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "LIST_VERSIONS", "INVALID_PAGE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 20);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      const { field, direction } = this.parseVersionOrderBy(orderBy);
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const countResult = await this.#db.client.one(`SELECT COUNT(*) as count FROM ${tableName} WHERE "agentId" = $1`, [
+        agentId
+      ]);
+      const total = parseInt(countResult.count, 10);
+      if (total === 0) {
+        return {
+          versions: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const dataResult = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${tableName} WHERE "agentId" = $1 ORDER BY "${field}" ${direction} LIMIT $2 OFFSET $3`,
+        [agentId, limitValue, offset]
+      );
+      const versions = (dataResult || []).map((row) => this.parseVersionRow(row));
+      return {
+        versions,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "LIST_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersion(id) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      await this.#db.client.none(`DELETE FROM ${tableName} WHERE id = $1`, [id]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "DELETE_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersionsByAgentId(agentId) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      await this.#db.client.none(`DELETE FROM ${tableName} WHERE "agentId" = $1`, [agentId]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "DELETE_VERSIONS_BY_AGENT_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error$1
+      );
+    }
+  }
+  async countVersions(agentId) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const result = await this.#db.client.one(`SELECT COUNT(*) as count FROM ${tableName} WHERE "agentId" = $1`, [
+        agentId
+      ]);
+      return parseInt(result.count, 10);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "COUNT_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  parseVersionRow(row) {
+    return {
+      id: row.id,
+      agentId: row.agentId,
+      versionNumber: row.versionNumber,
+      name: row.name,
+      snapshot: this.parseJson(row.snapshot, "snapshot"),
+      changedFields: this.parseJson(row.changedFields, "changedFields"),
+      changeMessage: row.changeMessage,
+      createdAt: row.createdAtZ || row.createdAt
+    };
+  }
 };
 function getSchemaName3(schema) {
   return schema ? `"${schema}"` : '"public"';
@@ -5040,11 +5291,13 @@ var ObservabilityPG = class _ObservabilityPG extends storage.ObservabilityStorag
           perPage,
           hasMore: (page + 1) * perPage < count
         },
-        spans: spans.map(
-          (span) => transformFromSqlRow({
-            tableName: storage.TABLE_SPANS,
-            sqlRow: span
-          })
+        spans: storage.toTraceSpans(
+          spans.map(
+            (span) => transformFromSqlRow({
+              tableName: storage.TABLE_SPANS,
+              sqlRow: span
+            })
+          )
         )
       };
     } catch (error$1) {