@mastra/pg 1.0.0-beta.10 → 1.0.0-beta.12

package/dist/index.cjs

@@ -8,7 +8,6 @@ var asyncMutex = require('async-mutex');
 var pg = require('pg');
 var xxhash = require('xxhash-wasm');
 var filter = require('@mastra/core/vector/filter');
-var pgPromise = require('pg-promise');
 var base = require('@mastra/core/base');
 var agent = require('@mastra/core/agent');
 var evals = require('@mastra/core/evals');
@@ -35,13 +34,15 @@ function _interopNamespace(e) {
 
 var pg__namespace = /*#__PURE__*/_interopNamespace(pg);
 var xxhash__default = /*#__PURE__*/_interopDefault(xxhash);
-var pgPromise__default = /*#__PURE__*/_interopDefault(pgPromise);
 
 // src/vector/index.ts
 
 // src/shared/config.ts
+var isPoolConfig = (cfg) => {
+  return "pool" in cfg;
+};
 var isConnectionStringConfig = (cfg) => {
-  return "connectionString" in cfg;
+  return "connectionString" in cfg && typeof cfg.connectionString === "string";
 };
 var isHostConfig = (cfg) => {
   return "host" in cfg && "database" in cfg && "user" in cfg && "password" in cfg;
@@ -49,16 +50,13 @@ var isHostConfig = (cfg) => {
 var isCloudSqlConfig = (cfg) => {
   return "stream" in cfg || "password" in cfg && typeof cfg.password === "function";
 };
-var isClientConfig = (cfg) => {
-  return "client" in cfg;
-};
 var validateConfig = (name, config) => {
   if (!config.id || typeof config.id !== "string" || config.id.trim() === "") {
     throw new Error(`${name}: id must be provided and cannot be empty.`);
   }
-  if (isClientConfig(config)) {
-    if (!config.client) {
-      throw new Error(`${name}: client must be provided when using client config.`);
+  if (isPoolConfig(config)) {
+    if (!config.pool) {
+      throw new Error(`${name}: pool must be provided when using pool config.`);
     }
     return;
   }
@@ -79,7 +77,7 @@ var validateConfig = (name, config) => {
     }
   } else {
     throw new Error(
-      `${name}: invalid config. Provide either {client}, {connectionString}, {host,port,database,user,password}, or a pg ClientConfig (e.g., Cloud SQL connector with \`stream\`).`
+      `${name}: invalid config. Provide either {pool}, {connectionString}, {host,port,database,user,password}, or a pg ClientConfig (e.g., Cloud SQL connector with \`stream\`).`
     );
   }
 };
@@ -544,8 +542,8 @@ var PgVector = class extends vector.MastraVector {
       } else if (isCloudSqlConfig(config)) {
         poolConfig = {
           ...config,
-          max: config.max ?? 20,
-          idleTimeoutMillis: config.idleTimeoutMillis ?? 3e4,
+          max: config.pgPoolOptions?.max ?? 20,
+          idleTimeoutMillis: config.pgPoolOptions?.idleTimeoutMillis ?? 3e4,
           connectionTimeoutMillis: 2e3,
           ...config.pgPoolOptions
         };
@@ -1687,6 +1685,132 @@ var PgVector = class extends vector.MastraVector {
     }
   }
 };
+
+// src/storage/client.ts
+function truncateQuery(query, maxLength = 100) {
+  const normalized = query.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return normalized.slice(0, maxLength) + "...";
+}
+var PoolAdapter = class {
+  constructor($pool) {
+    this.$pool = $pool;
+  }
+  connect() {
+    return this.$pool.connect();
+  }
+  async none(query, values) {
+    await this.$pool.query(query, values);
+    return null;
+  }
+  async one(query, values) {
+    const result = await this.$pool.query(query, values);
+    if (result.rows.length === 0) {
+      throw new Error(`No data returned from query: ${truncateQuery(query)}`);
+    }
+    if (result.rows.length > 1) {
+      throw new Error(`Multiple rows returned when one was expected: ${truncateQuery(query)}`);
+    }
+    return result.rows[0];
+  }
+  async oneOrNone(query, values) {
+    const result = await this.$pool.query(query, values);
+    if (result.rows.length === 0) {
+      return null;
+    }
+    if (result.rows.length > 1) {
+      throw new Error(`Multiple rows returned when one or none was expected: ${truncateQuery(query)}`);
+    }
+    return result.rows[0];
+  }
+  async any(query, values) {
+    const result = await this.$pool.query(query, values);
+    return result.rows;
+  }
+  async manyOrNone(query, values) {
+    return this.any(query, values);
+  }
+  async many(query, values) {
+    const result = await this.$pool.query(query, values);
+    if (result.rows.length === 0) {
+      throw new Error(`No data returned from query: ${truncateQuery(query)}`);
+    }
+    return result.rows;
+  }
+  async query(query, values) {
+    return this.$pool.query(query, values);
+  }
+  async tx(callback) {
+    const client = await this.$pool.connect();
+    try {
+      await client.query("BEGIN");
+      const txClient = new TransactionClient(client);
+      const result = await callback(txClient);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      try {
+        await client.query("ROLLBACK");
+      } catch (rollbackError) {
+        console.error("Transaction rollback failed:", rollbackError);
+      }
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+};
+var TransactionClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async none(query, values) {
+    await this.client.query(query, values);
+    return null;
+  }
+  async one(query, values) {
+    const result = await this.client.query(query, values);
+    if (result.rows.length === 0) {
+      throw new Error(`No data returned from query: ${truncateQuery(query)}`);
+    }
+    if (result.rows.length > 1) {
+      throw new Error(`Multiple rows returned when one was expected: ${truncateQuery(query)}`);
+    }
+    return result.rows[0];
+  }
+  async oneOrNone(query, values) {
+    const result = await this.client.query(query, values);
+    if (result.rows.length === 0) {
+      return null;
+    }
+    if (result.rows.length > 1) {
+      throw new Error(`Multiple rows returned when one or none was expected: ${truncateQuery(query)}`);
+    }
+    return result.rows[0];
+  }
+  async any(query, values) {
+    const result = await this.client.query(query, values);
+    return result.rows;
+  }
+  async manyOrNone(query, values) {
+    return this.any(query, values);
+  }
+  async many(query, values) {
+    const result = await this.client.query(query, values);
+    if (result.rows.length === 0) {
+      throw new Error(`No data returned from query: ${truncateQuery(query)}`);
+    }
+    return result.rows;
+  }
+  async query(query, values) {
+    return this.client.query(query, values);
+  }
+  async batch(promises) {
+    return Promise.all(promises);
+  }
+};
 function resolvePgConfig(config) {
   if ("client" in config) {
     return {
@@ -1696,10 +1820,32 @@ function resolvePgConfig(config) {
       indexes: config.indexes
     };
   }
-  const pgp = pgPromise__default.default();
-  const client = pgp(config);
+  if ("pool" in config) {
+    return {
+      client: new PoolAdapter(config.pool),
+      schemaName: config.schemaName,
+      skipDefaultIndexes: config.skipDefaultIndexes,
+      indexes: config.indexes
+    };
+  }
+  let pool;
+  if ("connectionString" in config) {
+    pool = new pg.Pool({
+      connectionString: config.connectionString,
+      ssl: config.ssl
+    });
+  } else {
+    pool = new pg.Pool({
+      host: config.host,
+      port: config.port,
+      database: config.database,
+      user: config.user,
+      password: config.password,
+      ssl: config.ssl
+    });
+  }
   return {
-    client,
+    client: new PoolAdapter(pool),
     schemaName: config.schemaName,
     skipDefaultIndexes: config.skipDefaultIndexes,
     indexes: config.indexes
@@ -1714,6 +1860,87 @@ function getTableName({ indexName, schemaName }) {
   const quotedSchemaName = schemaName;
   return quotedSchemaName ? `${quotedSchemaName}.${quotedIndexName}` : quotedIndexName;
 }
+function mapToSqlType(type) {
+  switch (type) {
+    case "uuid":
+      return "UUID";
+    case "boolean":
+      return "BOOLEAN";
+    default:
+      return storage.getSqlType(type);
+  }
+}
+function generateTableSQL({
+  tableName,
+  schema,
+  schemaName
+}) {
+  const timeZColumns = Object.entries(schema).filter(([_, def]) => def.type === "timestamp").map(([name]) => {
+    const parsedName = utils.parseSqlIdentifier(name, "column name");
+    return `"${parsedName}Z" TIMESTAMPTZ DEFAULT NOW()`;
+  });
+  const columns = Object.entries(schema).map(([name, def]) => {
+    const parsedName = utils.parseSqlIdentifier(name, "column name");
+    const constraints = [];
+    if (def.primaryKey) constraints.push("PRIMARY KEY");
+    if (!def.nullable) constraints.push("NOT NULL");
+    return `"${parsedName}" ${mapToSqlType(def.type)} ${constraints.join(" ")}`;
+  });
+  const finalColumns = [...columns, ...timeZColumns].join(",\n");
+  const parsedSchemaName = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
+  const constraintPrefix = parsedSchemaName ? `${parsedSchemaName}_` : "";
+  const quotedSchemaName = getSchemaName(schemaName);
+  const sql = `
+            CREATE TABLE IF NOT EXISTS ${getTableName({ indexName: tableName, schemaName: quotedSchemaName })} (
+              ${finalColumns}
+            );
+            ${tableName === storage.TABLE_WORKFLOW_SNAPSHOT ? `
+            DO $$ BEGIN
+              IF NOT EXISTS (
+                SELECT 1 FROM pg_constraint WHERE conname = '${constraintPrefix}mastra_workflow_snapshot_workflow_name_run_id_key'
+              ) AND NOT EXISTS (
+                SELECT 1 FROM pg_indexes WHERE indexname = '${constraintPrefix}mastra_workflow_snapshot_workflow_name_run_id_key'
+              ) THEN
+                ALTER TABLE ${getTableName({ indexName: tableName, schemaName: quotedSchemaName })}
+                ADD CONSTRAINT ${constraintPrefix}mastra_workflow_snapshot_workflow_name_run_id_key
+                UNIQUE (workflow_name, run_id);
+              END IF;
+            END $$;
+            ` : ""}
+          ${tableName === storage.TABLE_SPANS ? `
+            DO $$ BEGIN
+              IF NOT EXISTS (
+                SELECT 1 FROM pg_constraint WHERE conname = '${constraintPrefix}mastra_ai_spans_traceid_spanid_pk'
+              ) THEN
+                ALTER TABLE ${getTableName({ indexName: tableName, schemaName: quotedSchemaName })}
+                ADD CONSTRAINT ${constraintPrefix}mastra_ai_spans_traceid_spanid_pk
+                PRIMARY KEY ("traceId", "spanId");
+              END IF;
+            END $$;
+            ` : ""}
+          `;
+  return sql;
+}
+function exportSchemas(schemaName) {
+  const statements = [];
+  if (schemaName) {
+    const quotedSchemaName = getSchemaName(schemaName);
+    statements.push(`-- Create schema if it doesn't exist`);
+    statements.push(`CREATE SCHEMA IF NOT EXISTS ${quotedSchemaName};`);
+    statements.push("");
+  }
+  for (const [tableName, schema] of Object.entries(storage.TABLE_SCHEMAS)) {
+    statements.push(`-- Table: ${tableName}`);
+    const sql = generateTableSQL({
+      tableName,
+      schema,
+      schemaName
+    });
+    statements.push(sql.trim());
+    statements.push("");
+  }
+  return statements.join("\n");
+}
 var schemaSetupRegistry = /* @__PURE__ */ new Map();
 var PgDB = class extends base.MastraBase {
   client;
@@ -1831,16 +2058,6 @@ var PgDB = class extends base.MastraBase {
     }
     await registryEntry.promise;
   }
-  getSqlType(type) {
-    switch (type) {
-      case "uuid":
-        return "UUID";
-      case "boolean":
-        return "BOOLEAN";
-      default:
-        return storage.getSqlType(type);
-    }
-  }
   getDefaultValue(type) {
     switch (type) {
       case "timestamp":
@@ -1910,52 +2127,10 @@ var PgDB = class extends base.MastraBase {
   }) {
     try {
       const timeZColumnNames = Object.entries(schema).filter(([_, def]) => def.type === "timestamp").map(([name]) => name);
-      const timeZColumns = Object.entries(schema).filter(([_, def]) => def.type === "timestamp").map(([name]) => {
-        const parsedName = utils.parseSqlIdentifier(name, "column name");
-        return `"${parsedName}Z" TIMESTAMPTZ DEFAULT NOW()`;
-      });
-      const columns = Object.entries(schema).map(([name, def]) => {
-        const parsedName = utils.parseSqlIdentifier(name, "column name");
-        const constraints = [];
-        if (def.primaryKey) constraints.push("PRIMARY KEY");
-        if (!def.nullable) constraints.push("NOT NULL");
-        return `"${parsedName}" ${this.getSqlType(def.type)} ${constraints.join(" ")}`;
-      });
       if (this.schemaName) {
         await this.setupSchema();
       }
-      const finalColumns = [...columns, ...timeZColumns].join(",\n");
-      const constraintPrefix = this.schemaName ? `${this.schemaName}_` : "";
-      const schemaName = getSchemaName(this.schemaName);
-      const sql = `
-            CREATE TABLE IF NOT EXISTS ${getTableName({ indexName: tableName, schemaName })} (
-              ${finalColumns}
-            );
-            ${tableName === storage.TABLE_WORKFLOW_SNAPSHOT ? `
-            DO $$ BEGIN
-              IF NOT EXISTS (
-                SELECT 1 FROM pg_constraint WHERE conname = '${constraintPrefix}mastra_workflow_snapshot_workflow_name_run_id_key'
-              ) AND NOT EXISTS (
-                SELECT 1 FROM pg_indexes WHERE indexname = '${constraintPrefix}mastra_workflow_snapshot_workflow_name_run_id_key'
-              ) THEN
-                ALTER TABLE ${getTableName({ indexName: tableName, schemaName })}
-                ADD CONSTRAINT ${constraintPrefix}mastra_workflow_snapshot_workflow_name_run_id_key
-                UNIQUE (workflow_name, run_id);
-              END IF;
-            END $$;
-            ` : ""}
-          ${tableName === storage.TABLE_SPANS ? `
-            DO $$ BEGIN
-              IF NOT EXISTS (
-                SELECT 1 FROM pg_constraint WHERE conname = '${constraintPrefix}mastra_ai_spans_traceid_spanid_pk'
-              ) THEN
-                ALTER TABLE ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })}
-                ADD CONSTRAINT ${constraintPrefix}mastra_ai_spans_traceid_spanid_pk
-                PRIMARY KEY ("traceId", "spanId");
-              END IF;
-            END $$;
-            ` : ""}
-          `;
+      const sql = generateTableSQL({ tableName, schema, schemaName: this.schemaName });
       await this.client.none(sql);
       await this.alterTable({
         tableName,
@@ -2029,7 +2204,7 @@ var PgDB = class extends base.MastraBase {
         const columnExists = await this.hasColumn(storage.TABLE_SPANS, columnName);
         if (!columnExists) {
           const parsedColumnName = utils.parseSqlIdentifier(columnName, "column name");
-          const sqlType = this.getSqlType(columnDef.type);
+          const sqlType = mapToSqlType(columnDef.type);
           const nullable = columnDef.nullable ? "" : "NOT NULL";
           const defaultValue = !columnDef.nullable ? this.getDefaultValue(columnDef.type) : "";
           const alterSql = `ALTER TABLE ${fullTableName} ADD COLUMN IF NOT EXISTS "${parsedColumnName}" ${sqlType} ${nullable} ${defaultValue}`.trim();
@@ -2076,7 +2251,7 @@ var PgDB = class extends base.MastraBase {
         if (schema[columnName]) {
           const columnDef = schema[columnName];
           const parsedColumnName = utils.parseSqlIdentifier(columnName, "column name");
-          const sqlType = this.getSqlType(columnDef.type);
+          const sqlType = mapToSqlType(columnDef.type);
           const nullable = columnDef.nullable ? "" : "NOT NULL";
           const defaultValue = !columnDef.nullable ? this.getDefaultValue(columnDef.type) : "";
           const alterSql = `ALTER TABLE ${fullTableName} ADD COLUMN IF NOT EXISTS "${parsedColumnName}" ${sqlType} ${nullable} ${defaultValue}`.trim();
@@ -2396,9 +2571,9 @@ var PgDB = class extends base.MastraBase {
         size: result.size || "0",
         definition: result.definition || "",
         method: result.method || "btree",
-        scans: parseInt(result.scans) || 0,
-        tuples_read: parseInt(result.tuples_read) || 0,
-        tuples_fetched: parseInt(result.tuples_fetched) || 0
+        scans: parseInt(String(result.scans)) || 0,
+        tuples_read: parseInt(String(result.tuples_read)) || 0,
+        tuples_fetched: parseInt(String(result.tuples_fetched)) || 0
       };
     } catch (error$1) {
       throw new error.MastraError(
@@ -2915,6 +3090,9 @@ function getTableName3({ indexName, schemaName }) {
   const quotedIndexName = `"${indexName}"`;
   return schemaName ? `${schemaName}.${quotedIndexName}` : quotedIndexName;
 }
+function inPlaceholders(count, startIndex = 1) {
+  return Array.from({ length: count }, (_, i) => `$${i + startIndex}`).join(", ");
+}
 var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   #db;
   #schema;
@@ -3075,13 +3253,19 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
         };
       }
       const limitValue = perPageInput === false ? total : perPage;
-      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "${field}" ${direction} LIMIT $2 OFFSET $3`;
-      const rows = await this.#db.client.manyOrNone(dataQuery, [...queryParams, limitValue, offset]);
+      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "createdAtZ", "updatedAt", "updatedAtZ" ${baseQuery} ORDER BY "${field}" ${direction} LIMIT $2 OFFSET $3`;
+      const rows = await this.#db.client.manyOrNone(
+        dataQuery,
+        [...queryParams, limitValue, offset]
+      );
       const threads = (rows || []).map((thread) => ({
-        ...thread,
+        id: thread.id,
+        resourceId: thread.resourceId,
+        title: thread.title,
         metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-        createdAt: thread.createdAt,
-        updatedAt: thread.updatedAt
+        // Use timezone-aware columns (*Z) for correct UTC timestamps, with fallback for legacy data
+        createdAt: thread.createdAtZ || thread.createdAt,
+        updatedAt: thread.updatedAtZ || thread.updatedAt
       }));
       return {
         threads,
@@ -3186,17 +3370,18 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       ...metadata
     };
     try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
       const thread = await this.#db.client.one(
         `UPDATE ${threadTableName}
                     SET
                         title = $1,
                         metadata = $2,
                         "updatedAt" = $3,
-                        "updatedAtZ" = $3
-                    WHERE id = $4
+                        "updatedAtZ" = $4
+                    WHERE id = $5
                     RETURNING *
                 `,
-        [title, mergedMetadata, (/* @__PURE__ */ new Date()).toISOString(), id]
+        [title, mergedMetadata, now, now, id]
       );
       return {
         id: thread.id,
@@ -3339,7 +3524,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       const tableName = getTableName3({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) });
       const query = `
         ${selectStatement} FROM ${tableName}
-        WHERE id IN (${messageIds.map((_, i) => `$${i + 1}`).join(", ")})
+        WHERE id IN (${inPlaceholders(messageIds.length)})
         ORDER BY "createdAt" DESC
       `;
       const resultRows = await this.#db.client.manyOrNone(query, messageIds);
@@ -3400,8 +3585,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       const orderByStatement = `ORDER BY "${field}" ${direction}`;
       const selectStatement = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
       const tableName = getTableName3({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) });
-      const threadPlaceholders = threadIds.map((_, i) => `$${i + 1}`).join(", ");
-      const conditions = [`thread_id IN (${threadPlaceholders})`];
+      const conditions = [`thread_id IN (${inPlaceholders(threadIds.length)})`];
       const queryParams = [...threadIds];
       let paramIndex = threadIds.length + 1;
       if (resourceId) {
@@ -3409,11 +3593,13 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
         queryParams.push(resourceId);
       }
       if (filter?.dateRange?.start) {
-        conditions.push(`"createdAt" >= $${paramIndex++}`);
+        const startOp = filter.dateRange.startExclusive ? ">" : ">=";
+        conditions.push(`"createdAt" ${startOp} $${paramIndex++}`);
         queryParams.push(filter.dateRange.start);
       }
       if (filter?.dateRange?.end) {
-        conditions.push(`"createdAt" <= $${paramIndex++}`);
+        const endOp = filter.dateRange.endExclusive ? "<" : "<=";
+        conditions.push(`"createdAt" ${endOp} $${paramIndex++}`);
         queryParams.push(filter.dateRange.end);
       }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
@@ -3558,14 +3744,15 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
           );
         });
         const threadTableName = getTableName3({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName3(this.#schema) });
+        const nowStr = (/* @__PURE__ */ new Date()).toISOString();
         const threadUpdate = t.none(
           `UPDATE ${threadTableName}
                         SET
                             "updatedAt" = $1,
-                            "updatedAtZ" = $1
-                        WHERE id = $2
+                            "updatedAtZ" = $2
+                        WHERE id = $3
                     `,
-          [(/* @__PURE__ */ new Date()).toISOString(), threadId]
+          [nowStr, nowStr, threadId]
         );
         await Promise.all([...messageInserts, threadUpdate]);
       });
@@ -3602,8 +3789,8 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       return [];
     }
     const messageIds = messages.map((m) => m.id);
-    const selectQuery = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId" FROM ${getTableName3({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) })} WHERE id IN ($1:list)`;
-    const existingMessagesDb = await this.#db.client.manyOrNone(selectQuery, [messageIds]);
+    const selectQuery = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId" FROM ${getTableName3({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) })} WHERE id IN (${inPlaceholders(messageIds.length)})`;
+    const existingMessagesDb = await this.#db.client.manyOrNone(selectQuery, messageIds);
     if (existingMessagesDb.length === 0) {
       return [];
     }
@@ -3664,10 +3851,11 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
         }
       }
       if (threadIdsToUpdate.size > 0) {
+        const threadIds = Array.from(threadIdsToUpdate);
         queries.push(
           t.none(
-            `UPDATE ${getTableName3({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName3(this.#schema) })} SET "updatedAt" = NOW(), "updatedAtZ" = NOW() WHERE id IN ($1:list)`,
-            [Array.from(threadIdsToUpdate)]
+            `UPDATE ${getTableName3({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName3(this.#schema) })} SET "updatedAt" = NOW(), "updatedAtZ" = NOW() WHERE id IN (${inPlaceholders(threadIds.length)})`,
+            threadIds
           )
         );
       }
@@ -3675,7 +3863,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
         await t.batch(queries);
       }
     });
-    const updatedMessages = await this.#db.client.manyOrNone(selectQuery, [messageIds]);
+    const updatedMessages = await this.#db.client.manyOrNone(selectQuery, messageIds);
     return (updatedMessages || []).map((row) => {
       const message = this.normalizeMessageRow(row);
       if (typeof message.content === "string") {
@@ -3787,15 +3975,159 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       values.push(JSON.stringify(updatedResource.metadata));
       paramIndex++;
     }
-    updates.push(`"updatedAt" = $${paramIndex}`);
-    values.push(updatedResource.updatedAt.toISOString());
+    const updatedAtStr = updatedResource.updatedAt.toISOString();
+    updates.push(`"updatedAt" = $${paramIndex++}`);
+    values.push(updatedAtStr);
     updates.push(`"updatedAtZ" = $${paramIndex++}`);
-    values.push(updatedResource.updatedAt.toISOString());
-    paramIndex++;
+    values.push(updatedAtStr);
     values.push(resourceId);
     await this.#db.client.none(`UPDATE ${tableName} SET ${updates.join(", ")} WHERE id = $${paramIndex}`, values);
     return updatedResource;
   }
+  async cloneThread(args) {
+    const { sourceThreadId, newThreadId: providedThreadId, resourceId, title, metadata, options } = args;
+    const sourceThread = await this.getThreadById({ threadId: sourceThreadId });
+    if (!sourceThread) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("PG", "CLONE_THREAD", "SOURCE_NOT_FOUND"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: `Source thread with id ${sourceThreadId} not found`,
+        details: { sourceThreadId }
+      });
+    }
+    const newThreadId = providedThreadId || crypto.randomUUID();
+    const existingThread = await this.getThreadById({ threadId: newThreadId });
+    if (existingThread) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("PG", "CLONE_THREAD", "THREAD_EXISTS"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: `Thread with id ${newThreadId} already exists`,
+        details: { newThreadId }
+      });
+    }
+    const threadTableName = getTableName3({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName3(this.#schema) });
+    const messageTableName = getTableName3({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName3(this.#schema) });
+    try {
+      return await this.#db.client.tx(async (t) => {
+        let messageQuery = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"
+                            FROM ${messageTableName} WHERE thread_id = $1`;
+        const messageParams = [sourceThreadId];
+        let paramIndex = 2;
+        if (options?.messageFilter?.startDate) {
+          messageQuery += ` AND "createdAt" >= $${paramIndex++}`;
+          messageParams.push(options.messageFilter.startDate);
+        }
+        if (options?.messageFilter?.endDate) {
+          messageQuery += ` AND "createdAt" <= $${paramIndex++}`;
+          messageParams.push(options.messageFilter.endDate);
+        }
+        if (options?.messageFilter?.messageIds && options.messageFilter.messageIds.length > 0) {
+          messageQuery += ` AND id IN (${options.messageFilter.messageIds.map(() => `$${paramIndex++}`).join(", ")})`;
+          messageParams.push(...options.messageFilter.messageIds);
+        }
+        messageQuery += ` ORDER BY "createdAt" ASC`;
+        if (options?.messageLimit && options.messageLimit > 0) {
+          const limitQuery = `SELECT * FROM (${messageQuery.replace('ORDER BY "createdAt" ASC', 'ORDER BY "createdAt" DESC')} LIMIT $${paramIndex}) AS limited ORDER BY "createdAt" ASC`;
+          messageParams.push(options.messageLimit);
+          messageQuery = limitQuery;
+        }
+        const sourceMessages = await t.manyOrNone(messageQuery, messageParams);
+        const now = /* @__PURE__ */ new Date();
+        const lastMessageId = sourceMessages.length > 0 ? sourceMessages[sourceMessages.length - 1].id : void 0;
+        const cloneMetadata = {
+          sourceThreadId,
+          clonedAt: now,
+          ...lastMessageId && { lastMessageId }
+        };
+        const newThread = {
+          id: newThreadId,
+          resourceId: resourceId || sourceThread.resourceId,
+          title: title || (sourceThread.title ? `Clone of ${sourceThread.title}` : void 0),
+          metadata: {
+            ...metadata,
+            clone: cloneMetadata
+          },
+          createdAt: now,
+          updatedAt: now
+        };
+        await t.none(
+          `INSERT INTO ${threadTableName} (
+            id,
+            "resourceId",
+            title,
+            metadata,
+            "createdAt",
+            "createdAtZ",
+            "updatedAt",
+            "updatedAtZ"
+          ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
+          [
+            newThread.id,
+            newThread.resourceId,
+            newThread.title,
+            newThread.metadata ? JSON.stringify(newThread.metadata) : null,
+            now,
+            now,
+            now,
+            now
+          ]
+        );
+        const clonedMessages = [];
+        const targetResourceId = resourceId || sourceThread.resourceId;
+        for (const sourceMsg of sourceMessages) {
+          const newMessageId = crypto.randomUUID();
+          const normalizedMsg = this.normalizeMessageRow(sourceMsg);
+          let parsedContent = normalizedMsg.content;
+          try {
+            parsedContent = JSON.parse(normalizedMsg.content);
+          } catch {
+          }
+          await t.none(
+            `INSERT INTO ${messageTableName} (id, thread_id, content, "createdAt", "createdAtZ", role, type, "resourceId")
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
+            [
+              newMessageId,
+              newThreadId,
+              typeof normalizedMsg.content === "string" ? normalizedMsg.content : JSON.stringify(normalizedMsg.content),
+              normalizedMsg.createdAt,
+              normalizedMsg.createdAt,
+              normalizedMsg.role,
+              normalizedMsg.type || "v2",
+              targetResourceId
+            ]
+          );
+          clonedMessages.push({
+            id: newMessageId,
+            threadId: newThreadId,
+            content: parsedContent,
+            role: normalizedMsg.role,
+            type: normalizedMsg.type,
+            createdAt: new Date(normalizedMsg.createdAt),
+            resourceId: targetResourceId
+          });
+        }
+        return {
+          thread: newThread,
+          clonedMessages
+        };
+      });
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) {
+        throw error$1;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "CLONE_THREAD", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { sourceThreadId, newThreadId }
+        },
+        error$1
+      );
+    }
+  }
 };
 var ObservabilityPG = class _ObservabilityPG extends storage.ObservabilityStorage {
   #db;
@@ -5070,9 +5402,12 @@ var WorkflowsPG = class _WorkflowsPG extends storage.WorkflowsStorage {
 };
 
 // src/storage/index.ts
+var DEFAULT_MAX_CONNECTIONS = 20;
+var DEFAULT_IDLE_TIMEOUT_MS = 3e4;
 var PostgresStore = class extends storage.MastraStorage {
+  #pool;
   #db;
-  #pgp;
+  #ownsPool;
   schema;
   isInitialized = false;
   stores;
@@ -5081,59 +5416,26 @@ var PostgresStore = class extends storage.MastraStorage {
       validateConfig("PostgresStore", config);
       super({ id: config.id, name: "PostgresStore", disableInit: config.disableInit });
       this.schema = config.schemaName || "public";
-      this.#pgp = pgPromise__default.default();
-      if (isClientConfig(config)) {
-        this.#db = config.client;
+      if (isPoolConfig(config)) {
+        this.#pool = config.pool;
+        this.#ownsPool = false;
       } else {
-        let pgConfig;
-        if (isConnectionStringConfig(config)) {
-          pgConfig = {
-            id: config.id,
-            connectionString: config.connectionString,
-            max: config.max,
-            idleTimeoutMillis: config.idleTimeoutMillis,
-            ssl: config.ssl
-          };
-        } else if (isCloudSqlConfig(config)) {
-          pgConfig = {
-            ...config,
-            id: config.id,
-            max: config.max,
-            idleTimeoutMillis: config.idleTimeoutMillis
-          };
-        } else if (isHostConfig(config)) {
-          pgConfig = {
-            id: config.id,
-            host: config.host,
-            port: config.port,
-            database: config.database,
-            user: config.user,
-            password: config.password,
-            ssl: config.ssl,
-            max: config.max,
-            idleTimeoutMillis: config.idleTimeoutMillis
-          };
-        } else {
-          throw new Error(
-            "PostgresStore: invalid config. Provide either {client}, {connectionString}, {host,port,database,user,password}, or a pg ClientConfig (e.g., Cloud SQL connector with `stream`)."
-          );
-        }
-        this.#db = this.#pgp(pgConfig);
-      }
-      const skipDefaultIndexes = config.skipDefaultIndexes;
-      const indexes = config.indexes;
-      const domainConfig = { client: this.#db, schemaName: this.schema, skipDefaultIndexes, indexes };
-      const scores = new ScoresPG(domainConfig);
-      const workflows = new WorkflowsPG(domainConfig);
-      const memory = new MemoryPG(domainConfig);
-      const observability = new ObservabilityPG(domainConfig);
-      const agents = new AgentsPG(domainConfig);
+        this.#pool = this.createPool(config);
+        this.#ownsPool = true;
+      }
+      this.#db = new PoolAdapter(this.#pool);
+      const domainConfig = {
+        client: this.#db,
+        schemaName: this.schema,
+        skipDefaultIndexes: config.skipDefaultIndexes,
+        indexes: config.indexes
+      };
       this.stores = {
-        scores,
-        workflows,
-        memory,
-        observability,
-        agents
+        scores: new ScoresPG(domainConfig),
+        workflows: new WorkflowsPG(domainConfig),
+        memory: new MemoryPG(domainConfig),
+        observability: new ObservabilityPG(domainConfig),
+        agents: new AgentsPG(domainConfig)
       };
     } catch (e) {
       throw new error.MastraError(
@@ -5146,6 +5448,32 @@ var PostgresStore = class extends storage.MastraStorage {
       );
     }
   }
+  createPool(config) {
+    if (isConnectionStringConfig(config)) {
+      return new pg.Pool({
+        connectionString: config.connectionString,
+        ssl: config.ssl,
+        max: config.max ?? DEFAULT_MAX_CONNECTIONS,
+        idleTimeoutMillis: config.idleTimeoutMillis ?? DEFAULT_IDLE_TIMEOUT_MS
+      });
+    }
+    if (isHostConfig(config)) {
+      return new pg.Pool({
+        host: config.host,
+        port: config.port,
+        database: config.database,
+        user: config.user,
+        password: config.password,
+        ssl: config.ssl,
+        max: config.max ?? DEFAULT_MAX_CONNECTIONS,
+        idleTimeoutMillis: config.idleTimeoutMillis ?? DEFAULT_IDLE_TIMEOUT_MS
+      });
+    }
+    if (isCloudSqlConfig(config)) {
+      return new pg.Pool(config);
+    }
+    throw new Error("PostgresStore: invalid config");
+  }
   async init() {
     if (this.isInitialized) {
       return;
@@ -5165,19 +5493,32 @@ var PostgresStore = class extends storage.MastraStorage {
       );
     }
   }
+  /**
+   * Database client for executing queries.
+   *
+   * @example
+   * ```typescript
+   * const rows = await store.db.any('SELECT * FROM users WHERE active = $1', [true]);
+   * const user = await store.db.one('SELECT * FROM users WHERE id = $1', [userId]);
+   * ```
+   */
   get db() {
     return this.#db;
   }
-  get pgp() {
-    return this.#pgp;
+  /**
+   * The underlying pg.Pool for direct database access or ORM integration.
+   */
+  get pool() {
+    return this.#pool;
   }
   /**
-   * Closes the pg-promise connection pool.
-   *
-   * This will close ALL connections in the pool, including pre-configured clients.
+   * Closes the connection pool if it was created by this store.
+   * If a pool was passed in via config, it will not be closed.
    */
   async close() {
-    this.pgp.end();
+    if (this.#ownsPool) {
+      await this.#pool.end();
+    }
   }
 };
 
@@ -5285,8 +5626,10 @@ exports.MemoryPG = MemoryPG;
 exports.ObservabilityPG = ObservabilityPG;
 exports.PGVECTOR_PROMPT = PGVECTOR_PROMPT;
 exports.PgVector = PgVector;
+exports.PoolAdapter = PoolAdapter;
 exports.PostgresStore = PostgresStore;
 exports.ScoresPG = ScoresPG;
 exports.WorkflowsPG = WorkflowsPG;
+exports.exportSchemas = exportSchemas;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map