@mastra/pg 1.3.0 → 1.4.0

package/dist/index.cjs

@@ -36,7 +36,12 @@ function _interopNamespace(e) {
 var pg__namespace = /*#__PURE__*/_interopNamespace(pg);
 var xxhash__default = /*#__PURE__*/_interopDefault(xxhash);
 
-// src/vector/index.ts
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/shared/config.ts
 var isPoolConfig = (cfg) => {
@@ -1996,8 +2001,17 @@ function generateTableSQL({
   tableName,
   schema,
   schemaName,
+  compositePrimaryKey,
   includeAllConstraints = false
 }) {
+  if (compositePrimaryKey) {
+    for (const col of compositePrimaryKey) {
+      if (!(col in schema)) {
+        throw new Error(`compositePrimaryKey column "${col}" does not exist in schema for table "${tableName}"`);
+      }
+    }
+  }
+  const compositePKSet = compositePrimaryKey ? new Set(compositePrimaryKey) : null;
   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()`;
@@ -2005,11 +2019,16 @@ function generateTableSQL({
   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.primaryKey && !compositePKSet?.has(name)) 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 tableConstraints = [];
+  if (compositePrimaryKey) {
+    const pkCols = compositePrimaryKey.map((c) => `"${utils.parseSqlIdentifier(c, "column name")}"`).join(", ");
+    tableConstraints.push(`PRIMARY KEY (${pkCols})`);
+  }
+  const finalColumns = [...columns, ...timeZColumns, ...tableConstraints].join(",\n");
   const parsedSchemaName = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
   const workflowSnapshotConstraint = buildConstraintName({
     baseName: "mastra_workflow_snapshot_workflow_name_run_id_key",
@@ -2053,27 +2072,55 @@ function generateTableSQL({
           `;
   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,
-      includeAllConstraints: true
-      // Include all constraints for exports/documentation
-    });
-    statements.push(sql.trim());
-    statements.push("");
-  }
-  return statements.join("\n");
+function generateIndexSQL(options, schemaName) {
+  const { name, table, columns, unique = false, where, method = "btree" } = options;
+  const quotedSchemaName = getSchemaName(schemaName);
+  const fullTableName = getTableName({ indexName: table, schemaName: quotedSchemaName });
+  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 `"${utils.parseSqlIdentifier(colName, "column name")}" ${modifiers.join(" ")}`;
+    }
+    return `"${utils.parseSqlIdentifier(col, "column name")}"`;
+  }).join(", ");
+  const whereStr = where ? ` WHERE ${where}` : "";
+  const quotedIndexName = `"${utils.parseSqlIdentifier(name, "index name")}"`;
+  return `CREATE ${uniqueStr}INDEX IF NOT EXISTS ${quotedIndexName} ON ${fullTableName} ${methodStr}(${columnsStr})${whereStr};`;
+}
+function generateTimestampTriggerSQL(tableName, schemaName) {
+  const quotedSchemaName = getSchemaName(schemaName);
+  const fullTableName = getTableName({ indexName: tableName, schemaName: quotedSchemaName });
+  const functionName = `${quotedSchemaName}.trigger_set_timestamps`;
+  const triggerName = `"${utils.parseSqlIdentifier(`${tableName}_timestamps`, "trigger name")}"`;
+  return `CREATE OR REPLACE FUNCTION ${functionName}()
+RETURNS TRIGGER AS $$
+BEGIN
+    IF TG_OP = 'INSERT' THEN
+        NEW."createdAt" = NOW();
+        NEW."updatedAt" = NOW();
+        NEW."createdAtZ" = NOW();
+        NEW."updatedAtZ" = NOW();
+    ELSIF TG_OP = 'UPDATE' THEN
+        NEW."updatedAt" = NOW();
+        NEW."updatedAtZ" = NOW();
+        NEW."createdAt" = OLD."createdAt";
+        NEW."createdAtZ" = OLD."createdAtZ";
+    END IF;
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+DROP TRIGGER IF EXISTS ${triggerName} ON ${fullTableName};
+
+CREATE TRIGGER ${triggerName}
+    BEFORE INSERT OR UPDATE ON ${fullTableName}
+    FOR EACH ROW
+    EXECUTE FUNCTION ${functionName}();`;
 }
 var schemaSetupRegistry = /* @__PURE__ */ new Map();
 var PgDB = class extends base.MastraBase {
@@ -2274,14 +2321,15 @@ var PgDB = class extends base.MastraBase {
   }
   async createTable({
     tableName,
-    schema
+    schema,
+    compositePrimaryKey
   }) {
     try {
       const timeZColumnNames = Object.entries(schema).filter(([_, def]) => def.type === "timestamp").map(([name]) => name);
       if (this.schemaName) {
         await this.setupSchema();
       }
-      const sql = generateTableSQL({ tableName, schema, schemaName: this.schemaName });
+      const sql = generateTableSQL({ tableName, schema, schemaName: this.schemaName, compositePrimaryKey });
       await this.client.none(sql);
       await this.alterTable({
         tableName,
@@ -2345,36 +2393,9 @@ Note: This migration may take some time for large tables.
     }
   }
   async setupTimestampTriggers(tableName) {
-    const schemaName = getSchemaName(this.schemaName);
-    const fullTableName = getTableName({ indexName: tableName, schemaName });
-    const functionName = `${schemaName}.trigger_set_timestamps`;
-    try {
-      const triggerSQL = `
-        CREATE OR REPLACE FUNCTION ${functionName}()
-        RETURNS TRIGGER AS $$
-        BEGIN
-            IF TG_OP = 'INSERT' THEN
-                NEW."createdAt" = NOW();
-                NEW."updatedAt" = NOW();
-                NEW."createdAtZ" = NOW();
-                NEW."updatedAtZ" = NOW();
-            ELSIF TG_OP = 'UPDATE' THEN
-                NEW."updatedAt" = NOW();
-                NEW."updatedAtZ" = NOW();
-                NEW."createdAt" = OLD."createdAt";
-                NEW."createdAtZ" = OLD."createdAtZ";
-            END IF;
-            RETURN NEW;
-        END;
-        $$ LANGUAGE plpgsql;
-
-        DROP TRIGGER IF EXISTS ${tableName}_timestamps ON ${fullTableName};
-
-        CREATE TRIGGER ${tableName}_timestamps
-            BEFORE INSERT OR UPDATE ON ${fullTableName}
-            FOR EACH ROW
-            EXECUTE FUNCTION ${functionName}();
-      `;
+    const fullTableName = getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) });
+    try {
+      const triggerSQL = generateTimestampTriggerSQL(tableName, this.schemaName);
       await this.client.none(triggerSQL);
       this.logger?.debug?.(`Set up timestamp triggers for table ${fullTableName}`);
     } catch (error) {
@@ -3167,6 +3188,24 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
     this.#skipDefaultIndexes = skipDefaultIndexes;
     this.#indexes = indexes?.filter((idx) => _AgentsPG.MANAGED_TABLES.includes(idx.table));
   }
+  /**
+   * Returns all DDL statements for this domain: tables.
+   * Used by exportSchemas to produce a complete, reproducible schema export.
+   */
+  static getExportDDL(schemaName) {
+    const statements = [];
+    for (const tableName of _AgentsPG.MANAGED_TABLES) {
+      statements.push(
+        generateTableSQL({
+          tableName,
+          schema: storage.TABLE_SCHEMAS[tableName],
+          schemaName,
+          includeAllConstraints: true
+        })
+      );
+    }
+    return statements;
+  }
   /**
    * Returns default index definitions for the agents domain tables.
    * Currently no default indexes are defined for agents.
@@ -3512,7 +3551,9 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
         "inputProcessors",
         "outputProcessors",
         "memory",
-        "scorers"
+        "scorers",
+        "mcpClients",
+        "requestContextSchema"
       ];
       const hasConfigUpdate = configFieldNames.some((field) => field in configFields);
       if (hasConfigUpdate) {
@@ -3642,16 +3683,1975 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
         },
         new Error("page must be >= 0")
       );
-    }
-    const perPage = storage.normalizePerPage(perPageInput, 100);
-    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-    try {
-      const tableName = getTableName2({ indexName: storage.TABLE_AGENTS, schemaName: getSchemaName2(this.#schema) });
-      const countResult = await this.#db.client.one(`SELECT COUNT(*) as count FROM ${tableName}`);
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENTS, schemaName: getSchemaName2(this.#schema) });
+      const countResult = await this.#db.client.one(`SELECT COUNT(*) as count FROM ${tableName}`);
+      const total = parseInt(countResult.count, 10);
+      if (total === 0) {
+        return {
+          agents: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const dataResult = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${tableName} ORDER BY "${field}" ${direction} LIMIT $1 OFFSET $2`,
+        [limitValue, offset]
+      );
+      const agents = (dataResult || []).map((row) => this.parseRow(row));
+      return {
+        agents,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "LIST_AGENTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // 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, description, instructions, model, tools,
+          "defaultOptions", workflows, agents, "integrationTools",
+          "inputProcessors", "outputProcessors", memory, scorers,
+          "mcpClients", "requestContextSchema", "changedFields", "changeMessage",
+          "createdAt", "createdAtZ"
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22)`,
+        [
+          input.id,
+          input.agentId,
+          input.versionNumber,
+          input.name,
+          input.description ?? null,
+          this.serializeInstructions(input.instructions),
+          JSON.stringify(input.model),
+          input.tools ? JSON.stringify(input.tools) : null,
+          input.defaultOptions ? JSON.stringify(input.defaultOptions) : null,
+          input.workflows ? JSON.stringify(input.workflows) : null,
+          input.agents ? JSON.stringify(input.agents) : null,
+          input.integrationTools ? JSON.stringify(input.integrationTools) : null,
+          input.inputProcessors ? JSON.stringify(input.inputProcessors) : null,
+          input.outputProcessors ? JSON.stringify(input.outputProcessors) : null,
+          input.memory ? JSON.stringify(input.memory) : null,
+          input.scorers ? JSON.stringify(input.scorers) : null,
+          input.mcpClients ? JSON.stringify(input.mcpClients) : null,
+          input.requestContextSchema ? JSON.stringify(input.requestContextSchema) : null,
+          input.changedFields ? JSON.stringify(input.changedFields) : null,
+          input.changeMessage ?? null,
+          nowIso,
+          nowIso
+        ]
+      );
+      return {
+        ...input,
+        createdAt: now
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw 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) {
+      if (error$1 instanceof error.MastraError) throw 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) {
+      if (error$1 instanceof error.MastraError) throw 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) {
+      if (error$1 instanceof error.MastraError) throw 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) {
+      if (error$1 instanceof error.MastraError) throw 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) {
+      if (error$1 instanceof error.MastraError) throw 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 deleteVersionsByParentId(entityId) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      await this.#db.client.none(`DELETE FROM ${tableName} WHERE "agentId" = $1`, [entityId]);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw 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: entityId }
+        },
+        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) {
+      if (error$1 instanceof error.MastraError) throw 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
+  // ==========================================================================
+  serializeInstructions(instructions) {
+    if (instructions == null) return void 0;
+    return Array.isArray(instructions) ? JSON.stringify(instructions) : instructions;
+  }
+  deserializeInstructions(raw) {
+    if (!raw) return "";
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) return parsed;
+    } catch {
+    }
+    return raw;
+  }
+  parseVersionRow(row) {
+    return {
+      id: row.id,
+      agentId: row.agentId,
+      versionNumber: row.versionNumber,
+      name: row.name,
+      description: row.description,
+      instructions: this.deserializeInstructions(row.instructions),
+      model: this.parseJson(row.model, "model"),
+      tools: this.parseJson(row.tools, "tools"),
+      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"),
+      mcpClients: this.parseJson(row.mcpClients, "mcpClients"),
+      requestContextSchema: this.parseJson(row.requestContextSchema, "requestContextSchema"),
+      changedFields: this.parseJson(row.changedFields, "changedFields"),
+      changeMessage: row.changeMessage,
+      createdAt: row.createdAtZ || row.createdAt
+    };
+  }
+};
+function jsonbArg(value) {
+  return value === void 0 || value === null ? null : JSON.stringify(value);
+}
+var DatasetsPG = class _DatasetsPG extends storage.DatasetsStorage {
+  #db;
+  #schema;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_TABLES = [storage.TABLE_DATASETS, storage.TABLE_DATASET_ITEMS, storage.TABLE_DATASET_VERSIONS];
+  constructor(config) {
+    super();
+    const { client, schemaName, skipDefaultIndexes, indexes } = resolvePgConfig(config);
+    this.#db = new PgDB({ client, schemaName, skipDefaultIndexes });
+    this.#schema = schemaName || "public";
+    this.#skipDefaultIndexes = skipDefaultIndexes;
+    this.#indexes = indexes?.filter((idx) => _DatasetsPG.MANAGED_TABLES.includes(idx.table));
+  }
+  static getExportDDL(schemaName) {
+    const statements = [];
+    for (const tableName of _DatasetsPG.MANAGED_TABLES) {
+      statements.push(
+        generateTableSQL({
+          tableName,
+          schema: storage.TABLE_SCHEMAS[tableName],
+          schemaName,
+          compositePrimaryKey: storage.TABLE_CONFIGS[tableName]?.compositePrimaryKey,
+          includeAllConstraints: true
+        })
+      );
+    }
+    return statements;
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_DATASETS, schema: storage.DATASETS_SCHEMA });
+    await this.#db.createTable({
+      tableName: storage.TABLE_DATASET_ITEMS,
+      schema: storage.DATASET_ITEMS_SCHEMA,
+      compositePrimaryKey: storage.TABLE_CONFIGS[storage.TABLE_DATASET_ITEMS]?.compositePrimaryKey
+    });
+    await this.#db.createTable({ tableName: storage.TABLE_DATASET_VERSIONS, schema: storage.DATASET_VERSIONS_SCHEMA });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  getDefaultIndexDefinitions() {
+    return [
+      { name: "idx_dataset_items_dataset_validto", table: storage.TABLE_DATASET_ITEMS, columns: ["datasetId", "validTo"] },
+      {
+        name: "idx_dataset_items_dataset_version",
+        table: storage.TABLE_DATASET_ITEMS,
+        columns: ["datasetId", "datasetVersion"]
+      },
+      {
+        name: "idx_dataset_items_dataset_validto_deleted",
+        table: storage.TABLE_DATASET_ITEMS,
+        columns: ["datasetId", "validTo", "isDeleted"]
+      },
+      {
+        name: "idx_dataset_versions_dataset_version",
+        table: storage.TABLE_DATASET_VERSIONS,
+        columns: ["datasetId", "version"]
+      },
+      {
+        name: "idx_dataset_versions_dataset_version_unique",
+        table: storage.TABLE_DATASET_VERSIONS,
+        columns: ["datasetId", "version"],
+        unique: true
+      }
+    ];
+  }
+  async createDefaultIndexes() {
+    if (this.#skipDefaultIndexes) return;
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create default index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  async createCustomIndexes() {
+    if (!this.#indexes || this.#indexes.length === 0) return;
+    for (const indexDef of this.#indexes) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  // --- Row transformers ---
+  transformDatasetRow(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description ?? void 0,
+      metadata: row.metadata ? storage.safelyParseJSON(row.metadata) : void 0,
+      inputSchema: row.inputSchema ? storage.safelyParseJSON(row.inputSchema) : void 0,
+      groundTruthSchema: row.groundTruthSchema ? storage.safelyParseJSON(row.groundTruthSchema) : void 0,
+      version: row.version,
+      createdAt: storage.ensureDate(row.createdAtZ || row.createdAt),
+      updatedAt: storage.ensureDate(row.updatedAtZ || row.updatedAt)
+    };
+  }
+  transformItemRow(row) {
+    return {
+      id: row.id,
+      datasetId: row.datasetId,
+      datasetVersion: row.datasetVersion,
+      input: storage.safelyParseJSON(row.input),
+      groundTruth: row.groundTruth ? storage.safelyParseJSON(row.groundTruth) : void 0,
+      metadata: row.metadata ? storage.safelyParseJSON(row.metadata) : void 0,
+      createdAt: storage.ensureDate(row.createdAtZ || row.createdAt),
+      updatedAt: storage.ensureDate(row.updatedAtZ || row.updatedAt)
+    };
+  }
+  transformItemRowFull(row) {
+    return {
+      id: row.id,
+      datasetId: row.datasetId,
+      datasetVersion: row.datasetVersion,
+      validTo: row.validTo,
+      isDeleted: Boolean(row.isDeleted),
+      input: storage.safelyParseJSON(row.input),
+      groundTruth: row.groundTruth ? storage.safelyParseJSON(row.groundTruth) : void 0,
+      metadata: row.metadata ? storage.safelyParseJSON(row.metadata) : void 0,
+      createdAt: storage.ensureDate(row.createdAtZ || row.createdAt),
+      updatedAt: storage.ensureDate(row.updatedAtZ || row.updatedAt)
+    };
+  }
+  transformDatasetVersionRow(row) {
+    return {
+      id: row.id,
+      datasetId: row.datasetId,
+      version: row.version,
+      createdAt: storage.ensureDate(row.createdAtZ || row.createdAt)
+    };
+  }
+  // --- Dataset CRUD ---
+  async createDataset(input) {
+    try {
+      const id = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      await this.#db.insert({
+        tableName: storage.TABLE_DATASETS,
+        record: {
+          id,
+          name: input.name,
+          description: input.description ?? null,
+          metadata: input.metadata ?? null,
+          inputSchema: input.inputSchema ?? null,
+          groundTruthSchema: input.groundTruthSchema ?? null,
+          version: 0,
+          createdAt: nowIso,
+          updatedAt: nowIso
+        }
+      });
+      return {
+        id,
+        name: input.name,
+        description: input.description,
+        metadata: input.metadata,
+        inputSchema: input.inputSchema,
+        groundTruthSchema: input.groundTruthSchema,
+        version: 0,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "CREATE_DATASET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getDatasetById({ id }) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_DATASETS, schemaName: getSchemaName2(this.#schema) });
+      const result = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE "id" = $1`, [id]);
+      return result ? this.transformDatasetRow(result) : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "GET_DATASET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async _doUpdateDataset(args) {
+    try {
+      const existing = await this.getDatasetById({ id: args.id });
+      if (!existing) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("PG", "UPDATE_DATASET", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { datasetId: args.id }
+        });
+      }
+      const tableName = getTableName2({ indexName: storage.TABLE_DATASETS, schemaName: getSchemaName2(this.#schema) });
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const setClauses = ['"updatedAt" = $1', '"updatedAtZ" = $2'];
+      const values = [now, now];
+      let paramIndex = 3;
+      if (args.name !== void 0) {
+        setClauses.push(`"name" = $${paramIndex++}`);
+        values.push(args.name);
+      }
+      if (args.description !== void 0) {
+        setClauses.push(`"description" = $${paramIndex++}`);
+        values.push(args.description);
+      }
+      if (args.metadata !== void 0) {
+        setClauses.push(`"metadata" = $${paramIndex++}`);
+        values.push(JSON.stringify(args.metadata));
+      }
+      if (args.inputSchema !== void 0) {
+        setClauses.push(`"inputSchema" = $${paramIndex++}`);
+        values.push(args.inputSchema === null ? null : JSON.stringify(args.inputSchema));
+      }
+      if (args.groundTruthSchema !== void 0) {
+        setClauses.push(`"groundTruthSchema" = $${paramIndex++}`);
+        values.push(args.groundTruthSchema === null ? null : JSON.stringify(args.groundTruthSchema));
+      }
+      values.push(args.id);
+      await this.#db.client.none(
+        `UPDATE ${tableName} SET ${setClauses.join(", ")} WHERE "id" = $${paramIndex}`,
+        values
+      );
+      return {
+        ...existing,
+        name: args.name ?? existing.name,
+        description: args.description ?? existing.description,
+        metadata: args.metadata ?? existing.metadata,
+        inputSchema: args.inputSchema !== void 0 ? args.inputSchema : existing.inputSchema,
+        groundTruthSchema: args.groundTruthSchema !== void 0 ? args.groundTruthSchema : existing.groundTruthSchema,
+        updatedAt: new Date(now)
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "UPDATE_DATASET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async deleteDataset({ id }) {
+    try {
+      const datasetsTable = getTableName2({ indexName: storage.TABLE_DATASETS, schemaName: getSchemaName2(this.#schema) });
+      const itemsTable = getTableName2({ indexName: storage.TABLE_DATASET_ITEMS, schemaName: getSchemaName2(this.#schema) });
+      const versionsTable = getTableName2({
+        indexName: storage.TABLE_DATASET_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const experimentsTable = getTableName2({ indexName: storage.TABLE_EXPERIMENTS, schemaName: getSchemaName2(this.#schema) });
+      const experimentResultsTable = getTableName2({
+        indexName: storage.TABLE_EXPERIMENT_RESULTS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      try {
+        await this.#db.client.none(
+          `DELETE FROM ${experimentResultsTable} WHERE "experimentId" IN (SELECT "id" FROM ${experimentsTable} WHERE "datasetId" = $1)`,
+          [id]
+        );
+      } catch {
+      }
+      try {
+        await this.#db.client.none(
+          `UPDATE ${experimentsTable} SET "datasetId" = NULL, "datasetVersion" = NULL WHERE "datasetId" = $1`,
+          [id]
+        );
+      } catch {
+      }
+      await this.#db.client.tx(async (t) => {
+        await t.none(`DELETE FROM ${versionsTable} WHERE "datasetId" = $1`, [id]);
+        await t.none(`DELETE FROM ${itemsTable} WHERE "datasetId" = $1`, [id]);
+        await t.none(`DELETE FROM ${datasetsTable} WHERE "id" = $1`, [id]);
+      });
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "DELETE_DATASET", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listDatasets(args) {
+    try {
+      const { page, perPage: perPageInput } = args.pagination;
+      const tableName = getTableName2({ indexName: storage.TABLE_DATASETS, schemaName: getSchemaName2(this.#schema) });
+      const countResult = await this.#db.client.one(`SELECT COUNT(*) as count FROM ${tableName}`);
+      const total = parseInt(countResult.count, 10);
+      if (total === 0) {
+        return { datasets: [], pagination: { total: 0, page, perPage: perPageInput, hasMore: false } };
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const rows = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${tableName} ORDER BY "createdAt" DESC LIMIT $1 OFFSET $2`,
+        [limitValue, offset]
+      );
+      return {
+        datasets: (rows || []).map((row) => this.transformDatasetRow(row)),
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: perPageInput === false ? false : offset + perPage < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "LIST_DATASETS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // --- SCD-2 mutations ---
+  async _doAddItem(args) {
+    try {
+      const datasetsTable = getTableName2({ indexName: storage.TABLE_DATASETS, schemaName: getSchemaName2(this.#schema) });
+      const itemsTable = getTableName2({ indexName: storage.TABLE_DATASET_ITEMS, schemaName: getSchemaName2(this.#schema) });
+      const versionsTable = getTableName2({
+        indexName: storage.TABLE_DATASET_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const id = crypto.randomUUID();
+      const versionId = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      let newVersion;
+      await this.#db.client.tx(async (t) => {
+        const row = await t.one(
+          `UPDATE ${datasetsTable} SET "version" = "version" + 1 WHERE "id" = $1 RETURNING "version"`,
+          [args.datasetId]
+        );
+        newVersion = row.version;
+        await t.none(
+          `INSERT INTO ${itemsTable} ("id","datasetId","datasetVersion","validTo","isDeleted","input","groundTruth","metadata","createdAt","createdAtZ","updatedAt","updatedAtZ") VALUES ($1,$2,$3,NULL,false,$4,$5,$6,$7,$8,$9,$10)`,
+          [
+            id,
+            args.datasetId,
+            newVersion,
+            JSON.stringify(args.input),
+            jsonbArg(args.groundTruth),
+            jsonbArg(args.metadata),
+            nowIso,
+            nowIso,
+            nowIso,
+            nowIso
+          ]
+        );
+        await t.none(
+          `INSERT INTO ${versionsTable} ("id","datasetId","version","createdAt","createdAtZ") VALUES ($1,$2,$3,$4,$5)`,
+          [versionId, args.datasetId, newVersion, nowIso, nowIso]
+        );
+      });
+      return {
+        id,
+        datasetId: args.datasetId,
+        datasetVersion: newVersion,
+        input: args.input,
+        groundTruth: args.groundTruth,
+        metadata: args.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "ADD_ITEM", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async _doUpdateItem(args) {
+    try {
+      const existing = await this.getItemById({ id: args.id });
+      if (!existing) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("PG", "UPDATE_ITEM", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { itemId: args.id }
+        });
+      }
+      if (existing.datasetId !== args.datasetId) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("PG", "UPDATE_ITEM", "DATASET_MISMATCH"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { itemId: args.id, expectedDatasetId: args.datasetId, actualDatasetId: existing.datasetId }
+        });
+      }
+      const datasetsTable = getTableName2({ indexName: storage.TABLE_DATASETS, schemaName: getSchemaName2(this.#schema) });
+      const itemsTable = getTableName2({ indexName: storage.TABLE_DATASET_ITEMS, schemaName: getSchemaName2(this.#schema) });
+      const versionsTable = getTableName2({
+        indexName: storage.TABLE_DATASET_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const versionId = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      const mergedInput = args.input ?? existing.input;
+      const mergedGroundTruth = args.groundTruth ?? existing.groundTruth;
+      const mergedMetadata = args.metadata ?? existing.metadata;
+      let newVersion;
+      await this.#db.client.tx(async (t) => {
+        const row = await t.one(
+          `UPDATE ${datasetsTable} SET "version" = "version" + 1 WHERE "id" = $1 RETURNING "version"`,
+          [args.datasetId]
+        );
+        newVersion = row.version;
+        await t.none(
+          `UPDATE ${itemsTable} SET "validTo" = $1 WHERE "id" = $2 AND "validTo" IS NULL AND "isDeleted" = false`,
+          [newVersion, args.id]
+        );
+        await t.none(
+          `INSERT INTO ${itemsTable} ("id","datasetId","datasetVersion","validTo","isDeleted","input","groundTruth","metadata","createdAt","createdAtZ","updatedAt","updatedAtZ") VALUES ($1,$2,$3,NULL,false,$4,$5,$6,$7,$8,$9,$10)`,
+          [
+            args.id,
+            args.datasetId,
+            newVersion,
+            JSON.stringify(mergedInput),
+            jsonbArg(mergedGroundTruth),
+            jsonbArg(mergedMetadata),
+            existing.createdAt.toISOString(),
+            existing.createdAt.toISOString(),
+            nowIso,
+            nowIso
+          ]
+        );
+        await t.none(
+          `INSERT INTO ${versionsTable} ("id","datasetId","version","createdAt","createdAtZ") VALUES ($1,$2,$3,$4,$5)`,
+          [versionId, args.datasetId, newVersion, nowIso, nowIso]
+        );
+      });
+      return {
+        ...existing,
+        datasetVersion: newVersion,
+        input: mergedInput,
+        groundTruth: mergedGroundTruth,
+        metadata: mergedMetadata,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "UPDATE_ITEM", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async _doDeleteItem({ id, datasetId }) {
+    try {
+      const existing = await this.getItemById({ id });
+      if (!existing) return;
+      if (existing.datasetId !== datasetId) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("PG", "DELETE_ITEM", "DATASET_MISMATCH"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { itemId: id, expectedDatasetId: datasetId, actualDatasetId: existing.datasetId }
+        });
+      }
+      const datasetsTable = getTableName2({ indexName: storage.TABLE_DATASETS, schemaName: getSchemaName2(this.#schema) });
+      const itemsTable = getTableName2({ indexName: storage.TABLE_DATASET_ITEMS, schemaName: getSchemaName2(this.#schema) });
+      const versionsTable = getTableName2({
+        indexName: storage.TABLE_DATASET_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const versionId = crypto.randomUUID();
+      const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+      await this.#db.client.tx(async (t) => {
+        const row = await t.one(
+          `UPDATE ${datasetsTable} SET "version" = "version" + 1 WHERE "id" = $1 RETURNING "version"`,
+          [datasetId]
+        );
+        const newVersion = row.version;
+        await t.none(
+          `UPDATE ${itemsTable} SET "validTo" = $1 WHERE "id" = $2 AND "validTo" IS NULL AND "isDeleted" = false`,
+          [newVersion, id]
+        );
+        await t.none(
+          `INSERT INTO ${itemsTable} ("id","datasetId","datasetVersion","validTo","isDeleted","input","groundTruth","metadata","createdAt","createdAtZ","updatedAt","updatedAtZ") VALUES ($1,$2,$3,NULL,true,$4,$5,$6,$7,$8,$9,$10)`,
+          [
+            id,
+            datasetId,
+            newVersion,
+            JSON.stringify(existing.input),
+            jsonbArg(existing.groundTruth),
+            jsonbArg(existing.metadata),
+            existing.createdAt.toISOString(),
+            existing.createdAt.toISOString(),
+            nowIso,
+            nowIso
+          ]
+        );
+        await t.none(
+          `INSERT INTO ${versionsTable} ("id","datasetId","version","createdAt","createdAtZ") VALUES ($1,$2,$3,$4,$5)`,
+          [versionId, datasetId, newVersion, nowIso, nowIso]
+        );
+      });
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "DELETE_ITEM", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async _doBatchInsertItems(input) {
+    try {
+      const dataset = await this.getDatasetById({ id: input.datasetId });
+      if (!dataset) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("PG", "BULK_ADD_ITEMS", "DATASET_NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { datasetId: input.datasetId }
+        });
+      }
+      const datasetsTable = getTableName2({ indexName: storage.TABLE_DATASETS, schemaName: getSchemaName2(this.#schema) });
+      const itemsTable = getTableName2({ indexName: storage.TABLE_DATASET_ITEMS, schemaName: getSchemaName2(this.#schema) });
+      const versionsTable = getTableName2({
+        indexName: storage.TABLE_DATASET_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      const versionId = crypto.randomUUID();
+      const itemsWithIds = input.items.map((itemInput) => ({ id: crypto.randomUUID(), input: itemInput }));
+      let newVersion;
+      await this.#db.client.tx(async (t) => {
+        const row = await t.one(
+          `UPDATE ${datasetsTable} SET "version" = "version" + 1 WHERE "id" = $1 RETURNING "version"`,
+          [input.datasetId]
+        );
+        newVersion = row.version;
+        for (const { id, input: itemInput } of itemsWithIds) {
+          await t.none(
+            `INSERT INTO ${itemsTable} ("id","datasetId","datasetVersion","validTo","isDeleted","input","groundTruth","metadata","createdAt","createdAtZ","updatedAt","updatedAtZ") VALUES ($1,$2,$3,NULL,false,$4,$5,$6,$7,$8,$9,$10)`,
+            [
+              id,
+              input.datasetId,
+              newVersion,
+              JSON.stringify(itemInput.input),
+              jsonbArg(itemInput.groundTruth),
+              jsonbArg(itemInput.metadata),
+              nowIso,
+              nowIso,
+              nowIso,
+              nowIso
+            ]
+          );
+        }
+        await t.none(
+          `INSERT INTO ${versionsTable} ("id","datasetId","version","createdAt","createdAtZ") VALUES ($1,$2,$3,$4,$5)`,
+          [versionId, input.datasetId, newVersion, nowIso, nowIso]
+        );
+      });
+      return itemsWithIds.map(({ id, input: itemInput }) => ({
+        id,
+        datasetId: input.datasetId,
+        datasetVersion: newVersion,
+        input: itemInput.input,
+        groundTruth: itemInput.groundTruth,
+        metadata: itemInput.metadata,
+        createdAt: now,
+        updatedAt: now
+      }));
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "BULK_ADD_ITEMS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async _doBatchDeleteItems(input) {
+    try {
+      const dataset = await this.getDatasetById({ id: input.datasetId });
+      if (!dataset) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("PG", "BULK_DELETE_ITEMS", "DATASET_NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { datasetId: input.datasetId }
+        });
+      }
+      const currentItems = [];
+      for (const itemId of input.itemIds) {
+        const item = await this.getItemById({ id: itemId });
+        if (item && item.datasetId === input.datasetId) {
+          currentItems.push(item);
+        }
+      }
+      if (currentItems.length === 0) return;
+      const datasetsTable = getTableName2({ indexName: storage.TABLE_DATASETS, schemaName: getSchemaName2(this.#schema) });
+      const itemsTable = getTableName2({ indexName: storage.TABLE_DATASET_ITEMS, schemaName: getSchemaName2(this.#schema) });
+      const versionsTable = getTableName2({
+        indexName: storage.TABLE_DATASET_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+      const versionId = crypto.randomUUID();
+      await this.#db.client.tx(async (t) => {
+        const row = await t.one(
+          `UPDATE ${datasetsTable} SET "version" = "version" + 1 WHERE "id" = $1 RETURNING "version"`,
+          [input.datasetId]
+        );
+        const newVersion = row.version;
+        for (const item of currentItems) {
+          await t.none(
+            `UPDATE ${itemsTable} SET "validTo" = $1 WHERE "id" = $2 AND "validTo" IS NULL AND "isDeleted" = false`,
+            [newVersion, item.id]
+          );
+          await t.none(
+            `INSERT INTO ${itemsTable} ("id","datasetId","datasetVersion","validTo","isDeleted","input","groundTruth","metadata","createdAt","createdAtZ","updatedAt","updatedAtZ") VALUES ($1,$2,$3,NULL,true,$4,$5,$6,$7,$8,$9,$10)`,
+            [
+              item.id,
+              input.datasetId,
+              newVersion,
+              JSON.stringify(item.input),
+              jsonbArg(item.groundTruth),
+              jsonbArg(item.metadata),
+              item.createdAt.toISOString(),
+              item.createdAt.toISOString(),
+              nowIso,
+              nowIso
+            ]
+          );
+        }
+        await t.none(
+          `INSERT INTO ${versionsTable} ("id","datasetId","version","createdAt","createdAtZ") VALUES ($1,$2,$3,$4,$5)`,
+          [versionId, input.datasetId, newVersion, nowIso, nowIso]
+        );
+      });
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "BULK_DELETE_ITEMS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // --- SCD-2 queries ---
+  async getItemById(args) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_DATASET_ITEMS, schemaName: getSchemaName2(this.#schema) });
+      let result;
+      if (args.datasetVersion !== void 0) {
+        result = await this.#db.client.oneOrNone(
+          `SELECT * FROM ${tableName} WHERE "id" = $1 AND "datasetVersion" = $2 AND "isDeleted" = false`,
+          [args.id, args.datasetVersion]
+        );
+      } else {
+        result = await this.#db.client.oneOrNone(
+          `SELECT * FROM ${tableName} WHERE "id" = $1 AND "validTo" IS NULL AND "isDeleted" = false`,
+          [args.id]
+        );
+      }
+      return result ? this.transformItemRow(result) : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "GET_ITEM", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getItemsByVersion({ datasetId, version }) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_DATASET_ITEMS, schemaName: getSchemaName2(this.#schema) });
+      const rows = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${tableName} WHERE "datasetId" = $1 AND "datasetVersion" <= $2 AND ("validTo" IS NULL OR "validTo" > $3) AND "isDeleted" = false ORDER BY "createdAt" DESC`,
+        [datasetId, version, version]
+      );
+      return (rows || []).map((row) => this.transformItemRow(row));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "GET_ITEMS_BY_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getItemHistory(itemId) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_DATASET_ITEMS, schemaName: getSchemaName2(this.#schema) });
+      const rows = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${tableName} WHERE "id" = $1 ORDER BY "datasetVersion" DESC`,
+        [itemId]
+      );
+      return (rows || []).map((row) => this.transformItemRowFull(row));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "GET_ITEM_HISTORY", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listItems(args) {
+    try {
+      const { page, perPage: perPageInput } = args.pagination;
+      const tableName = getTableName2({ indexName: storage.TABLE_DATASET_ITEMS, schemaName: getSchemaName2(this.#schema) });
+      const conditions = ['"datasetId" = $1'];
+      const queryParams = [args.datasetId];
+      let paramIndex = 2;
+      if (args.version !== void 0) {
+        conditions.push(`"datasetVersion" <= $${paramIndex++}`);
+        queryParams.push(args.version);
+        conditions.push(`("validTo" IS NULL OR "validTo" > $${paramIndex++})`);
+        queryParams.push(args.version);
+        conditions.push(`"isDeleted" = false`);
+      } else {
+        conditions.push(`"validTo" IS NULL`);
+        conditions.push(`"isDeleted" = false`);
+      }
+      if (args.search) {
+        conditions.push(
+          `("input"::text ILIKE $${paramIndex} OR COALESCE("groundTruth"::text, '') ILIKE $${paramIndex})`
+        );
+        queryParams.push(`%${args.search}%`);
+        paramIndex++;
+      }
+      const whereClause = `WHERE ${conditions.join(" AND ")}`;
+      const countResult = await this.#db.client.one(
+        `SELECT COUNT(*) as count FROM ${tableName} ${whereClause}`,
+        queryParams
+      );
+      const total = parseInt(countResult.count, 10);
+      if (total === 0) {
+        return { items: [], pagination: { total: 0, page, perPage: perPageInput, hasMore: false } };
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const rows = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${tableName} ${whereClause} ORDER BY "createdAt" DESC LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`,
+        [...queryParams, limitValue, offset]
+      );
+      return {
+        items: (rows || []).map((row) => this.transformItemRow(row)),
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: perPageInput === false ? false : offset + perPage < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "LIST_ITEMS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // --- Dataset versions ---
+  async createDatasetVersion(datasetId, version) {
+    try {
+      const id = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      await this.#db.insert({
+        tableName: storage.TABLE_DATASET_VERSIONS,
+        record: { id, datasetId, version, createdAt: nowIso }
+      });
+      return { id, datasetId, version, createdAt: now };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "CREATE_DATASET_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listDatasetVersions(input) {
+    try {
+      const { page, perPage: perPageInput } = input.pagination;
+      const tableName = getTableName2({ indexName: storage.TABLE_DATASET_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const countResult = await this.#db.client.one(
+        `SELECT COUNT(*) as count FROM ${tableName} WHERE "datasetId" = $1`,
+        [input.datasetId]
+      );
+      const total = parseInt(countResult.count, 10);
+      if (total === 0) {
+        return { versions: [], pagination: { total: 0, page, perPage: perPageInput, hasMore: false } };
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const rows = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${tableName} WHERE "datasetId" = $1 ORDER BY "version" DESC LIMIT $2 OFFSET $3`,
+        [input.datasetId, limitValue, offset]
+      );
+      return {
+        versions: (rows || []).map((row) => this.transformDatasetVersionRow(row)),
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: perPageInput === false ? false : offset + perPage < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "LIST_DATASET_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // --- Clear ---
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_DATASET_VERSIONS });
+    await this.#db.clearTable({ tableName: storage.TABLE_DATASET_ITEMS });
+    await this.#db.clearTable({ tableName: storage.TABLE_DATASETS });
+  }
+};
+var ExperimentsPG = class _ExperimentsPG extends storage.ExperimentsStorage {
+  #db;
+  #schema;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_TABLES = [storage.TABLE_EXPERIMENTS, storage.TABLE_EXPERIMENT_RESULTS];
+  constructor(config) {
+    super();
+    const { client, schemaName, skipDefaultIndexes, indexes } = resolvePgConfig(config);
+    this.#db = new PgDB({ client, schemaName, skipDefaultIndexes });
+    this.#schema = schemaName || "public";
+    this.#skipDefaultIndexes = skipDefaultIndexes;
+    this.#indexes = indexes?.filter((idx) => _ExperimentsPG.MANAGED_TABLES.includes(idx.table));
+  }
+  static getExportDDL(schemaName) {
+    const statements = [];
+    for (const tableName of _ExperimentsPG.MANAGED_TABLES) {
+      statements.push(
+        generateTableSQL({
+          tableName,
+          schema: storage.TABLE_SCHEMAS[tableName],
+          schemaName,
+          includeAllConstraints: true
+        })
+      );
+    }
+    return statements;
+  }
+  async init() {
+    await this.#db.createTable({ tableName: storage.TABLE_EXPERIMENTS, schema: storage.EXPERIMENTS_SCHEMA });
+    await this.#db.createTable({ tableName: storage.TABLE_EXPERIMENT_RESULTS, schema: storage.EXPERIMENT_RESULTS_SCHEMA });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  getDefaultIndexDefinitions() {
+    return [
+      { name: "idx_experiments_datasetid", table: storage.TABLE_EXPERIMENTS, columns: ["datasetId"] },
+      { name: "idx_experiment_results_experimentid", table: storage.TABLE_EXPERIMENT_RESULTS, columns: ["experimentId"] },
+      {
+        name: "idx_experiment_results_exp_item",
+        table: storage.TABLE_EXPERIMENT_RESULTS,
+        columns: ["experimentId", "itemId"],
+        unique: true
+      }
+    ];
+  }
+  async createDefaultIndexes() {
+    if (this.#skipDefaultIndexes) return;
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create default index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  async createCustomIndexes() {
+    if (!this.#indexes || this.#indexes.length === 0) return;
+    for (const indexDef of this.#indexes) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  // --- Row transformers ---
+  transformExperimentRow(row) {
+    return {
+      id: row.id,
+      name: row.name ?? void 0,
+      description: row.description ?? void 0,
+      metadata: row.metadata ? storage.safelyParseJSON(row.metadata) : void 0,
+      datasetId: row.datasetId ?? null,
+      datasetVersion: row.datasetVersion != null ? row.datasetVersion : null,
+      targetType: row.targetType,
+      targetId: row.targetId,
+      status: row.status,
+      totalItems: row.totalItems,
+      succeededCount: row.succeededCount,
+      failedCount: row.failedCount,
+      skippedCount: row.skippedCount ?? 0,
+      startedAt: row.startedAt ? storage.ensureDate(row.startedAtZ || row.startedAt) : null,
+      completedAt: row.completedAt ? storage.ensureDate(row.completedAtZ || row.completedAt) : null,
+      createdAt: storage.ensureDate(row.createdAtZ || row.createdAt),
+      updatedAt: storage.ensureDate(row.updatedAtZ || row.updatedAt)
+    };
+  }
+  transformExperimentResultRow(row) {
+    return {
+      id: row.id,
+      experimentId: row.experimentId,
+      itemId: row.itemId,
+      itemDatasetVersion: row.itemDatasetVersion != null ? row.itemDatasetVersion : null,
+      input: storage.safelyParseJSON(row.input),
+      output: row.output ? storage.safelyParseJSON(row.output) : null,
+      groundTruth: row.groundTruth ? storage.safelyParseJSON(row.groundTruth) : null,
+      error: row.error ? storage.safelyParseJSON(row.error) : null,
+      startedAt: storage.ensureDate(row.startedAtZ || row.startedAt),
+      completedAt: storage.ensureDate(row.completedAtZ || row.completedAt),
+      retryCount: row.retryCount,
+      traceId: row.traceId ?? null,
+      createdAt: storage.ensureDate(row.createdAtZ || row.createdAt)
+    };
+  }
+  // --- Experiment CRUD ---
+  async createExperiment(input) {
+    try {
+      const id = input.id ?? crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      await this.#db.insert({
+        tableName: storage.TABLE_EXPERIMENTS,
+        record: {
+          id,
+          name: input.name ?? null,
+          description: input.description ?? null,
+          metadata: input.metadata ?? null,
+          datasetId: input.datasetId ?? null,
+          datasetVersion: input.datasetVersion ?? null,
+          targetType: input.targetType,
+          targetId: input.targetId,
+          status: "pending",
+          totalItems: input.totalItems,
+          succeededCount: 0,
+          failedCount: 0,
+          skippedCount: 0,
+          startedAt: null,
+          completedAt: null,
+          createdAt: nowIso,
+          updatedAt: nowIso
+        }
+      });
+      return {
+        id,
+        name: input.name,
+        description: input.description,
+        metadata: input.metadata,
+        datasetId: input.datasetId ?? null,
+        datasetVersion: input.datasetVersion ?? null,
+        targetType: input.targetType,
+        targetId: input.targetId,
+        status: "pending",
+        totalItems: input.totalItems,
+        succeededCount: 0,
+        failedCount: 0,
+        skippedCount: 0,
+        startedAt: null,
+        completedAt: null,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "CREATE_EXPERIMENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async updateExperiment(input) {
+    try {
+      const existing = await this.getExperimentById({ id: input.id });
+      if (!existing) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("PG", "UPDATE_EXPERIMENT", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { experimentId: input.id }
+        });
+      }
+      const tableName = getTableName2({ indexName: storage.TABLE_EXPERIMENTS, schemaName: getSchemaName2(this.#schema) });
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const setClauses = ['"updatedAt" = $1', '"updatedAtZ" = $2'];
+      const values = [now, now];
+      let paramIndex = 3;
+      if (input.name !== void 0) {
+        setClauses.push(`"name" = $${paramIndex++}`);
+        values.push(input.name);
+      }
+      if (input.description !== void 0) {
+        setClauses.push(`"description" = $${paramIndex++}`);
+        values.push(input.description);
+      }
+      if (input.metadata !== void 0) {
+        setClauses.push(`"metadata" = $${paramIndex++}`);
+        values.push(JSON.stringify(input.metadata));
+      }
+      if (input.status !== void 0) {
+        setClauses.push(`"status" = $${paramIndex++}`);
+        values.push(input.status);
+      }
+      if (input.succeededCount !== void 0) {
+        setClauses.push(`"succeededCount" = $${paramIndex++}`);
+        values.push(input.succeededCount);
+      }
+      if (input.failedCount !== void 0) {
+        setClauses.push(`"failedCount" = $${paramIndex++}`);
+        values.push(input.failedCount);
+      }
+      if (input.skippedCount !== void 0) {
+        setClauses.push(`"skippedCount" = $${paramIndex++}`);
+        values.push(input.skippedCount);
+      }
+      if (input.startedAt !== void 0) {
+        setClauses.push(`"startedAt" = $${paramIndex++}`);
+        values.push(input.startedAt?.toISOString() ?? null);
+      }
+      if (input.completedAt !== void 0) {
+        setClauses.push(`"completedAt" = $${paramIndex++}`);
+        values.push(input.completedAt?.toISOString() ?? null);
+      }
+      values.push(input.id);
+      await this.#db.client.none(
+        `UPDATE ${tableName} SET ${setClauses.join(", ")} WHERE "id" = $${paramIndex}`,
+        values
+      );
+      const updated = await this.getExperimentById({ id: input.id });
+      return updated;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "UPDATE_EXPERIMENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getExperimentById({ id }) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_EXPERIMENTS, schemaName: getSchemaName2(this.#schema) });
+      const result = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE "id" = $1`, [id]);
+      return result ? this.transformExperimentRow(result) : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "GET_EXPERIMENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listExperiments(args) {
+    try {
+      const { page, perPage: perPageInput } = args.pagination;
+      const tableName = getTableName2({ indexName: storage.TABLE_EXPERIMENTS, schemaName: getSchemaName2(this.#schema) });
+      const conditions = [];
+      const queryParams = [];
+      let paramIndex = 1;
+      if (args.datasetId) {
+        conditions.push(`"datasetId" = $${paramIndex++}`);
+        queryParams.push(args.datasetId);
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const countResult = await this.#db.client.one(
+        `SELECT COUNT(*) as count FROM ${tableName} ${whereClause}`,
+        queryParams
+      );
+      const total = parseInt(countResult.count, 10);
+      if (total === 0) {
+        return { experiments: [], pagination: { total: 0, page, perPage: perPageInput, hasMore: false } };
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const rows = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${tableName} ${whereClause} ORDER BY "createdAt" DESC LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`,
+        [...queryParams, limitValue, offset]
+      );
+      return {
+        experiments: (rows || []).map((row) => this.transformExperimentRow(row)),
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: perPageInput === false ? false : offset + perPage < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "LIST_EXPERIMENTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async deleteExperiment({ id }) {
+    try {
+      const resultsTable = getTableName2({
+        indexName: storage.TABLE_EXPERIMENT_RESULTS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const experimentsTable = getTableName2({ indexName: storage.TABLE_EXPERIMENTS, schemaName: getSchemaName2(this.#schema) });
+      await this.#db.client.none(`DELETE FROM ${resultsTable} WHERE "experimentId" = $1`, [id]);
+      await this.#db.client.none(`DELETE FROM ${experimentsTable} WHERE "id" = $1`, [id]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "DELETE_EXPERIMENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // --- Experiment results ---
+  async addExperimentResult(input) {
+    try {
+      const id = input.id ?? crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      await this.#db.insert({
+        tableName: storage.TABLE_EXPERIMENT_RESULTS,
+        record: {
+          id,
+          experimentId: input.experimentId,
+          itemId: input.itemId,
+          itemDatasetVersion: input.itemDatasetVersion ?? null,
+          input: input.input,
+          output: input.output ?? null,
+          groundTruth: input.groundTruth ?? null,
+          error: input.error ?? null,
+          startedAt: input.startedAt.toISOString(),
+          completedAt: input.completedAt.toISOString(),
+          retryCount: input.retryCount,
+          traceId: input.traceId ?? null,
+          createdAt: nowIso
+        }
+      });
+      return {
+        id,
+        experimentId: input.experimentId,
+        itemId: input.itemId,
+        itemDatasetVersion: input.itemDatasetVersion ?? null,
+        input: input.input,
+        output: input.output ?? null,
+        groundTruth: input.groundTruth ?? null,
+        error: input.error ?? null,
+        startedAt: input.startedAt,
+        completedAt: input.completedAt,
+        retryCount: input.retryCount,
+        traceId: input.traceId ?? null,
+        createdAt: now
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "ADD_EXPERIMENT_RESULT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getExperimentResultById({ id }) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_EXPERIMENT_RESULTS, schemaName: getSchemaName2(this.#schema) });
+      const result = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE "id" = $1`, [id]);
+      return result ? this.transformExperimentResultRow(result) : null;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "GET_EXPERIMENT_RESULT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async listExperimentResults(args) {
+    try {
+      const { page, perPage: perPageInput } = args.pagination;
+      const tableName = getTableName2({ indexName: storage.TABLE_EXPERIMENT_RESULTS, schemaName: getSchemaName2(this.#schema) });
+      const countResult = await this.#db.client.one(
+        `SELECT COUNT(*) as count FROM ${tableName} WHERE "experimentId" = $1`,
+        [args.experimentId]
+      );
+      const total = parseInt(countResult.count, 10);
+      if (total === 0) {
+        return { results: [], pagination: { total: 0, page, perPage: perPageInput, hasMore: false } };
+      }
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const rows = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${tableName} WHERE "experimentId" = $1 ORDER BY "startedAt" ASC LIMIT $2 OFFSET $3`,
+        [args.experimentId, limitValue, offset]
+      );
+      return {
+        results: (rows || []).map((row) => this.transformExperimentResultRow(row)),
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: perPageInput === false ? false : offset + perPage < total
+        }
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "LIST_EXPERIMENT_RESULTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async deleteExperimentResults({ experimentId }) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_EXPERIMENT_RESULTS, schemaName: getSchemaName2(this.#schema) });
+      await this.#db.client.none(`DELETE FROM ${tableName} WHERE "experimentId" = $1`, [experimentId]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "DELETE_EXPERIMENT_RESULTS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // --- Clear ---
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_EXPERIMENT_RESULTS });
+    await this.#db.clearTable({ tableName: storage.TABLE_EXPERIMENTS });
+  }
+};
+var SNAPSHOT_FIELDS = ["name", "description", "servers"];
+var MCPClientsPG = class _MCPClientsPG extends storage.MCPClientsStorage {
+  #db;
+  #schema;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_TABLES = [storage.TABLE_MCP_CLIENTS, storage.TABLE_MCP_CLIENT_VERSIONS];
+  constructor(config) {
+    super();
+    const { client, schemaName, skipDefaultIndexes, indexes } = resolvePgConfig(config);
+    this.#db = new PgDB({ client, schemaName, skipDefaultIndexes });
+    this.#schema = schemaName || "public";
+    this.#skipDefaultIndexes = skipDefaultIndexes;
+    this.#indexes = indexes?.filter((idx) => _MCPClientsPG.MANAGED_TABLES.includes(idx.table));
+  }
+  getDefaultIndexDefinitions() {
+    return [
+      {
+        name: "idx_mcp_client_versions_client_version",
+        table: storage.TABLE_MCP_CLIENT_VERSIONS,
+        columns: ["mcpClientId", "versionNumber"],
+        unique: true
+      }
+    ];
+  }
+  async createDefaultIndexes() {
+    if (this.#skipDefaultIndexes) {
+      return;
+    }
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch {
+      }
+    }
+  }
+  async init() {
+    await this.#db.createTable({
+      tableName: storage.TABLE_MCP_CLIENTS,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_MCP_CLIENTS]
+    });
+    await this.#db.createTable({
+      tableName: storage.TABLE_MCP_CLIENT_VERSIONS,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_MCP_CLIENT_VERSIONS]
+    });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  async createCustomIndexes() {
+    if (!this.#indexes || this.#indexes.length === 0) {
+      return;
+    }
+    for (const indexDef of this.#indexes) {
+      try {
+        await this.#db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: storage.TABLE_MCP_CLIENT_VERSIONS });
+    await this.#db.clearTable({ tableName: storage.TABLE_MCP_CLIENTS });
+  }
+  // ==========================================================================
+  // MCP Client CRUD Methods
+  // ==========================================================================
+  async getById(id) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_MCP_CLIENTS, schemaName: getSchemaName2(this.#schema) });
+      const result = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE id = $1`, [id]);
+      if (!result) {
+        return null;
+      }
+      return this.parseMCPClientRow(result);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "GET_MCP_CLIENT_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpClientId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async create(input) {
+    const { mcpClient } = input;
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_MCP_CLIENTS, schemaName: getSchemaName2(this.#schema) });
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      await this.#db.client.none(
+        `INSERT INTO ${tableName} (
+          id, status, "activeVersionId", "authorId", metadata,
+          "createdAt", "createdAtZ", "updatedAt", "updatedAtZ"
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
+        [
+          mcpClient.id,
+          "draft",
+          null,
+          mcpClient.authorId ?? null,
+          mcpClient.metadata ? JSON.stringify(mcpClient.metadata) : null,
+          nowIso,
+          nowIso,
+          nowIso,
+          nowIso
+        ]
+      );
+      const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = mcpClient;
+      const versionId = crypto.randomUUID();
+      await this.createVersion({
+        id: versionId,
+        mcpClientId: mcpClient.id,
+        versionNumber: 1,
+        ...snapshotConfig,
+        changedFields: [...SNAPSHOT_FIELDS],
+        changeMessage: "Initial version"
+      });
+      return {
+        id: mcpClient.id,
+        status: "draft",
+        activeVersionId: void 0,
+        authorId: mcpClient.authorId,
+        metadata: mcpClient.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      try {
+        const tableName = getTableName2({
+          indexName: storage.TABLE_MCP_CLIENTS,
+          schemaName: getSchemaName2(this.#schema)
+        });
+        await this.#db.client.none(
+          `DELETE FROM ${tableName} WHERE id = $1 AND status = 'draft' AND "activeVersionId" IS NULL`,
+          [mcpClient.id]
+        );
+      } catch {
+      }
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "CREATE_MCP_CLIENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpClientId: mcpClient.id }
+        },
+        error$1
+      );
+    }
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_MCP_CLIENTS, schemaName: getSchemaName2(this.#schema) });
+      const existingClient = await this.getById(id);
+      if (!existingClient) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("PG", "UPDATE_MCP_CLIENT", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: `MCP client ${id} not found`,
+          details: { mcpClientId: id }
+        });
+      }
+      const { authorId, activeVersionId, metadata, status, ...configFields } = updates;
+      let versionCreated = false;
+      const hasConfigUpdate = SNAPSHOT_FIELDS.some((field) => field in configFields);
+      if (hasConfigUpdate) {
+        const latestVersion = await this.getLatestVersion(id);
+        if (!latestVersion) {
+          throw new error.MastraError({
+            id: storage.createStorageErrorId("PG", "UPDATE_MCP_CLIENT", "NO_VERSIONS"),
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.SYSTEM,
+            text: `No versions found for MCP client ${id}`,
+            details: { mcpClientId: id }
+          });
+        }
+        const {
+          id: _versionId,
+          mcpClientId: _mcpClientId,
+          versionNumber: _versionNumber,
+          changedFields: _changedFields,
+          changeMessage: _changeMessage,
+          createdAt: _createdAt,
+          ...latestConfig
+        } = latestVersion;
+        const newConfig = { ...latestConfig, ...configFields };
+        const changedFields = SNAPSHOT_FIELDS.filter(
+          (field) => field in configFields && JSON.stringify(configFields[field]) !== JSON.stringify(latestConfig[field])
+        );
+        if (changedFields.length > 0) {
+          versionCreated = true;
+          const newVersionId = crypto.randomUUID();
+          await this.createVersion({
+            id: newVersionId,
+            mcpClientId: id,
+            versionNumber: latestVersion.versionNumber + 1,
+            ...newConfig,
+            changedFields: [...changedFields],
+            changeMessage: `Updated ${changedFields.join(", ")}`
+          });
+        }
+      }
+      const setClauses = [];
+      const values = [];
+      let paramIndex = 1;
+      if (authorId !== void 0) {
+        setClauses.push(`"authorId" = $${paramIndex++}`);
+        values.push(authorId);
+      }
+      if (activeVersionId !== void 0) {
+        setClauses.push(`"activeVersionId" = $${paramIndex++}`);
+        values.push(activeVersionId);
+        if (status === void 0) {
+          setClauses.push(`status = $${paramIndex++}`);
+          values.push("published");
+        }
+      }
+      if (status !== void 0) {
+        setClauses.push(`status = $${paramIndex++}`);
+        values.push(status);
+      }
+      if (metadata !== void 0) {
+        const mergedMetadata = { ...existingClient.metadata || {}, ...metadata };
+        setClauses.push(`metadata = $${paramIndex++}`);
+        values.push(JSON.stringify(mergedMetadata));
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      setClauses.push(`"updatedAt" = $${paramIndex++}`);
+      values.push(now);
+      setClauses.push(`"updatedAtZ" = $${paramIndex++}`);
+      values.push(now);
+      values.push(id);
+      if (setClauses.length > 2 || versionCreated) {
+        await this.#db.client.none(
+          `UPDATE ${tableName} SET ${setClauses.join(", ")} WHERE id = $${paramIndex}`,
+          values
+        );
+      }
+      const updatedClient = await this.getById(id);
+      if (!updatedClient) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("PG", "UPDATE_MCP_CLIENT", "NOT_FOUND_AFTER_UPDATE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: `MCP client ${id} not found after update`,
+          details: { mcpClientId: id }
+        });
+      }
+      return updatedClient;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "UPDATE_MCP_CLIENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpClientId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async delete(id) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_MCP_CLIENTS, schemaName: getSchemaName2(this.#schema) });
+      await this.deleteVersionsByParentId(id);
+      await this.#db.client.none(`DELETE FROM ${tableName} WHERE id = $1`, [id]);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "DELETE_MCP_CLIENT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpClientId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async list(args) {
+    const { page = 0, perPage: perPageInput, orderBy, authorId, metadata } = args || {};
+    const { field, direction } = this.parseOrderBy(orderBy);
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "LIST_MCP_CLIENTS", "INVALID_PAGE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_MCP_CLIENTS, schemaName: getSchemaName2(this.#schema) });
+      const conditions = [];
+      const queryParams = [];
+      let paramIdx = 1;
+      if (authorId !== void 0) {
+        conditions.push(`"authorId" = $${paramIdx++}`);
+        queryParams.push(authorId);
+      }
+      if (metadata && Object.keys(metadata).length > 0) {
+        conditions.push(`metadata @> $${paramIdx++}::jsonb`);
+        queryParams.push(JSON.stringify(metadata));
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const countResult = await this.#db.client.one(
+        `SELECT COUNT(*) as count FROM ${tableName} ${whereClause}`,
+        queryParams
+      );
       const total = parseInt(countResult.count, 10);
       if (total === 0) {
         return {
-          agents: [],
+          mcpClients: [],
           total: 0,
           page,
           perPage: perPageForResponse,
@@ -3660,12 +5660,12 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
       }
       const limitValue = perPageInput === false ? total : perPage;
       const dataResult = await this.#db.client.manyOrNone(
-        `SELECT * FROM ${tableName} ORDER BY "${field}" ${direction} LIMIT $1 OFFSET $2`,
-        [limitValue, offset]
+        `SELECT * FROM ${tableName} ${whereClause} ORDER BY "${field}" ${direction} LIMIT $${paramIdx++} OFFSET $${paramIdx++}`,
+        [...queryParams, limitValue, offset]
       );
-      const agents = (dataResult || []).map((row) => this.parseRow(row));
+      const mcpClients = (dataResult || []).map((row) => this.parseMCPClientRow(row));
       return {
-        agents,
+        mcpClients,
         total,
         page,
         perPage: perPageForResponse,
@@ -3675,7 +5675,7 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("PG", "LIST_AGENTS", "FAILED"),
+          id: storage.createStorageErrorId("PG", "LIST_MCP_CLIENTS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -3684,39 +5684,30 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
     }
   }
   // ==========================================================================
-  // Agent Version Methods
+  // MCP Client Version Methods
   // ==========================================================================
   async createVersion(input) {
     try {
-      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const tableName = getTableName2({
+        indexName: storage.TABLE_MCP_CLIENT_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, description, instructions, model, tools,
-          "defaultOptions", workflows, agents, "integrationTools",
-          "inputProcessors", "outputProcessors", memory, scorers,
+          id, "mcpClientId", "versionNumber",
+          name, description, servers,
           "changedFields", "changeMessage",
           "createdAt", "createdAtZ"
-        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20)`,
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`,
         [
           input.id,
-          input.agentId,
+          input.mcpClientId,
           input.versionNumber,
           input.name,
           input.description ?? null,
-          this.serializeInstructions(input.instructions),
-          JSON.stringify(input.model),
-          input.tools ? JSON.stringify(input.tools) : null,
-          input.defaultOptions ? JSON.stringify(input.defaultOptions) : null,
-          input.workflows ? JSON.stringify(input.workflows) : null,
-          input.agents ? JSON.stringify(input.agents) : null,
-          input.integrationTools ? JSON.stringify(input.integrationTools) : null,
-          input.inputProcessors ? JSON.stringify(input.inputProcessors) : null,
-          input.outputProcessors ? JSON.stringify(input.outputProcessors) : null,
-          input.memory ? JSON.stringify(input.memory) : null,
-          input.scorers ? JSON.stringify(input.scorers) : null,
+          JSON.stringify(input.servers),
           input.changedFields ? JSON.stringify(input.changedFields) : null,
           input.changeMessage ?? null,
           nowIso,
@@ -3731,10 +5722,10 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("PG", "CREATE_VERSION", "FAILED"),
+          id: storage.createStorageErrorId("PG", "CREATE_MCP_CLIENT_VERSION", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { versionId: input.id, agentId: input.agentId }
+          details: { versionId: input.id, mcpClientId: input.mcpClientId }
         },
         error$1
       );
@@ -3742,7 +5733,10 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
   }
   async getVersion(id) {
     try {
-      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const tableName = getTableName2({
+        indexName: storage.TABLE_MCP_CLIENT_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
       const result = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE id = $1`, [id]);
       if (!result) {
         return null;
@@ -3752,7 +5746,7 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("PG", "GET_VERSION", "FAILED"),
+          id: storage.createStorageErrorId("PG", "GET_MCP_CLIENT_VERSION", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { versionId: id }
@@ -3761,12 +5755,15 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
       );
     }
   }
-  async getVersionByNumber(agentId, versionNumber) {
+  async getVersionByNumber(mcpClientId, versionNumber) {
     try {
-      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const tableName = getTableName2({
+        indexName: storage.TABLE_MCP_CLIENT_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
       const result = await this.#db.client.oneOrNone(
-        `SELECT * FROM ${tableName} WHERE "agentId" = $1 AND "versionNumber" = $2`,
-        [agentId, versionNumber]
+        `SELECT * FROM ${tableName} WHERE "mcpClientId" = $1 AND "versionNumber" = $2`,
+        [mcpClientId, versionNumber]
       );
       if (!result) {
         return null;
@@ -3776,21 +5773,24 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("PG", "GET_VERSION_BY_NUMBER", "FAILED"),
+          id: storage.createStorageErrorId("PG", "GET_MCP_CLIENT_VERSION_BY_NUMBER", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { agentId, versionNumber }
+          details: { mcpClientId, versionNumber }
         },
         error$1
       );
     }
   }
-  async getLatestVersion(agentId) {
+  async getLatestVersion(mcpClientId) {
     try {
-      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const tableName = getTableName2({
+        indexName: storage.TABLE_MCP_CLIENT_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]
+        `SELECT * FROM ${tableName} WHERE "mcpClientId" = $1 ORDER BY "versionNumber" DESC LIMIT 1`,
+        [mcpClientId]
       );
       if (!result) {
         return null;
@@ -3800,21 +5800,21 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("PG", "GET_LATEST_VERSION", "FAILED"),
+          id: storage.createStorageErrorId("PG", "GET_LATEST_MCP_CLIENT_VERSION", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { agentId }
+          details: { mcpClientId }
         },
         error$1
       );
     }
   }
   async listVersions(input) {
-    const { agentId, page = 0, perPage: perPageInput, orderBy } = input;
+    const { mcpClientId, page = 0, perPage: perPageInput, orderBy } = input;
     if (page < 0) {
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("PG", "LIST_VERSIONS", "INVALID_PAGE"),
+          id: storage.createStorageErrorId("PG", "LIST_MCP_CLIENT_VERSIONS", "INVALID_PAGE"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: { page }
@@ -3826,10 +5826,14 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
     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 tableName = getTableName2({
+        indexName: storage.TABLE_MCP_CLIENT_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const countResult = await this.#db.client.one(
+        `SELECT COUNT(*) as count FROM ${tableName} WHERE "mcpClientId" = $1`,
+        [mcpClientId]
+      );
       const total = parseInt(countResult.count, 10);
       if (total === 0) {
         return {
@@ -3842,8 +5846,8 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
       }
       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]
+        `SELECT * FROM ${tableName} WHERE "mcpClientId" = $1 ORDER BY "${field}" ${direction} LIMIT $2 OFFSET $3`,
+        [mcpClientId, limitValue, offset]
       );
       const versions = (dataResult || []).map((row) => this.parseVersionRow(row));
       return {
@@ -3857,10 +5861,10 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("PG", "LIST_VERSIONS", "FAILED"),
+          id: storage.createStorageErrorId("PG", "LIST_MCP_CLIENT_VERSIONS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { agentId }
+          details: { mcpClientId }
         },
         error$1
       );
@@ -3868,13 +5872,16 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
   }
   async deleteVersion(id) {
     try {
-      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
+      const tableName = getTableName2({
+        indexName: storage.TABLE_MCP_CLIENT_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
       await this.#db.client.none(`DELETE FROM ${tableName} WHERE id = $1`, [id]);
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("PG", "DELETE_VERSION", "FAILED"),
+          id: storage.createStorageErrorId("PG", "DELETE_MCP_CLIENT_VERSION", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { versionId: id }
@@ -3885,36 +5892,42 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
   }
   async deleteVersionsByParentId(entityId) {
     try {
-      const tableName = getTableName2({ indexName: storage.TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.#schema) });
-      await this.#db.client.none(`DELETE FROM ${tableName} WHERE "agentId" = $1`, [entityId]);
+      const tableName = getTableName2({
+        indexName: storage.TABLE_MCP_CLIENT_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      await this.#db.client.none(`DELETE FROM ${tableName} WHERE "mcpClientId" = $1`, [entityId]);
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("PG", "DELETE_VERSIONS_BY_AGENT_ID", "FAILED"),
+          id: storage.createStorageErrorId("PG", "DELETE_MCP_CLIENT_VERSIONS_BY_MCP_CLIENT_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { agentId: entityId }
+          details: { mcpClientId: entityId }
         },
         error$1
       );
     }
   }
-  async countVersions(agentId) {
+  async countVersions(mcpClientId) {
     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
+      const tableName = getTableName2({
+        indexName: storage.TABLE_MCP_CLIENT_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const result = await this.#db.client.one(`SELECT COUNT(*) as count FROM ${tableName} WHERE "mcpClientId" = $1`, [
+        mcpClientId
       ]);
       return parseInt(result.count, 10);
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("PG", "COUNT_VERSIONS", "FAILED"),
+          id: storage.createStorageErrorId("PG", "COUNT_MCP_CLIENT_VERSIONS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { agentId }
+          details: { mcpClientId }
         },
         error$1
       );
@@ -3923,44 +5936,63 @@ var AgentsPG = class _AgentsPG extends storage.AgentsStorage {
   // ==========================================================================
   // Private Helper Methods
   // ==========================================================================
-  serializeInstructions(instructions) {
-    if (instructions == null) return void 0;
-    return Array.isArray(instructions) ? JSON.stringify(instructions) : instructions;
-  }
-  deserializeInstructions(raw) {
-    if (!raw) return "";
+  parseJson(value, fieldName) {
+    if (!value) return void 0;
+    if (typeof value !== "string") return value;
     try {
-      const parsed = JSON.parse(raw);
-      if (Array.isArray(parsed)) return parsed;
-    } catch {
+      return JSON.parse(value);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      const details = {
+        value: value.length > 100 ? value.substring(0, 100) + "..." : value
+      };
+      if (fieldName) {
+        details.field = fieldName;
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "PARSE_JSON", "INVALID_JSON"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: `Failed to parse JSON${fieldName ? ` for field "${fieldName}"` : ""}: ${error$1 instanceof Error ? error$1.message : "Unknown error"}`,
+          details
+        },
+        error$1
+      );
     }
-    return raw;
+  }
+  parseMCPClientRow(row) {
+    return {
+      id: row.id,
+      status: row.status,
+      activeVersionId: row.activeVersionId,
+      authorId: row.authorId,
+      metadata: this.parseJson(row.metadata, "metadata"),
+      createdAt: new Date(row.createdAtZ || row.createdAt),
+      updatedAt: new Date(row.updatedAtZ || row.updatedAt)
+    };
   }
   parseVersionRow(row) {
     return {
       id: row.id,
-      agentId: row.agentId,
+      mcpClientId: row.mcpClientId,
       versionNumber: row.versionNumber,
       name: row.name,
       description: row.description,
-      instructions: this.deserializeInstructions(row.instructions),
-      model: this.parseJson(row.model, "model"),
-      tools: this.parseJson(row.tools, "tools"),
-      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"),
+      servers: this.parseJson(row.servers, "servers"),
       changedFields: this.parseJson(row.changedFields, "changedFields"),
       changeMessage: row.changeMessage,
-      createdAt: row.createdAtZ || row.createdAt
+      createdAt: new Date(row.createdAtZ || row.createdAt)
     };
   }
 };
 var OM_TABLE = "mastra_observational_memory";
+var _omTableSchema;
+try {
+  const storage = __require("@mastra/core/storage");
+  _omTableSchema = storage.OBSERVATIONAL_MEMORY_TABLE_SCHEMA;
+} catch {
+}
 function getSchemaName3(schema) {
   return schema ? `"${schema}"` : '"public"';
 }
@@ -4039,9 +6071,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
   }
   /**
    * Returns default index definitions for the memory domain tables.
+   * @param schemaPrefix - Prefix for index names (e.g. "my_schema_" or "")
    */
-  getDefaultIndexDefinitions() {
-    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+  static getDefaultIndexDefs(schemaPrefix) {
     return [
       {
         name: `${schemaPrefix}mastra_threads_resourceid_createdat_idx`,
@@ -4055,6 +6087,53 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       }
     ];
   }
+  /**
+   * Returns all DDL statements for this domain: tables (threads, messages, resources, OM), indexes.
+   * Used by exportSchemas to produce a complete, reproducible schema export.
+   */
+  static getExportDDL(schemaName) {
+    const statements = [];
+    const parsedSchema = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
+    const schemaPrefix = parsedSchema && parsedSchema !== "public" ? `${parsedSchema}_` : "";
+    const quotedSchemaName = getSchemaName(schemaName);
+    for (const tableName of [storage.TABLE_THREADS, storage.TABLE_MESSAGES, storage.TABLE_RESOURCES]) {
+      statements.push(
+        generateTableSQL({
+          tableName,
+          schema: storage.TABLE_SCHEMAS[tableName],
+          schemaName,
+          includeAllConstraints: true
+        })
+      );
+    }
+    const omSchema = _omTableSchema?.[OM_TABLE];
+    if (omSchema) {
+      statements.push(
+        generateTableSQL({
+          tableName: OM_TABLE,
+          schema: omSchema,
+          schemaName,
+          includeAllConstraints: true
+        })
+      );
+      const fullOmTableName = getTableName({ indexName: OM_TABLE, schemaName: quotedSchemaName });
+      const idxPrefix = schemaPrefix ? `${schemaPrefix}` : "";
+      statements.push(
+        `CREATE INDEX IF NOT EXISTS "${idxPrefix}idx_om_lookup_key" ON ${fullOmTableName} ("lookupKey");`
+      );
+    }
+    for (const idx of _MemoryPG.getDefaultIndexDefs(schemaPrefix)) {
+      statements.push(generateIndexSQL(idx, schemaName));
+    }
+    return statements;
+  }
+  /**
+   * Returns default index definitions for this instance's schema.
+   */
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return _MemoryPG.getDefaultIndexDefs(schemaPrefix);
+  }
   /**
    * Creates default indexes for optimal query performance.
    */
@@ -5416,8 +7495,8 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
           input.observations,
           lastObservedAtStr,
           lastObservedAtStr,
-          input.tokenCount,
-          input.tokenCount,
+          Math.round(input.tokenCount),
+          Math.round(input.tokenCount),
           observedMessageIdsJson,
           nowStr,
           nowStr,
@@ -5512,8 +7591,8 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
           nowStr,
           // lastReflectionAtZ
           record.pendingMessageTokens,
-          record.totalTokensObserved,
-          record.observationTokenCount,
+          Math.round(record.totalTokensObserved),
+          Math.round(record.observationTokenCount),
           false,
           // isObserving
           false,
@@ -5631,7 +7710,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       let values;
       if (lastBufferedAtTokens !== void 0) {
         query = `UPDATE ${tableName} SET "isBufferingObservation" = $1, "lastBufferedAtTokens" = $2, "updatedAt" = $3, "updatedAtZ" = $4 WHERE id = $5`;
-        values = [isBuffering, lastBufferedAtTokens, nowStr, nowStr, id];
+        values = [isBuffering, Math.round(lastBufferedAtTokens), nowStr, nowStr, id];
       } else {
         query = `UPDATE ${tableName} SET "isBufferingObservation" = $1, "updatedAt" = $2, "updatedAtZ" = $3 WHERE id = $4`;
         values = [isBuffering, nowStr, nowStr, id];
@@ -5729,7 +7808,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
           "updatedAt" = $2,
           "updatedAtZ" = $3
         WHERE id = $4`,
-        [tokenCount, nowStr, nowStr, id]
+        [Math.round(tokenCount), nowStr, nowStr, id]
       );
       if (result.rowCount === 0) {
         throw new error.MastraError({
@@ -5769,9 +7848,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
         id: `ombuf-${crypto$1.randomUUID()}`,
         cycleId: input.chunk.cycleId,
         observations: input.chunk.observations,
-        tokenCount: input.chunk.tokenCount,
+        tokenCount: Math.round(input.chunk.tokenCount),
         messageIds: input.chunk.messageIds,
-        messageTokens: input.chunk.messageTokens,
+        messageTokens: Math.round(input.chunk.messageTokens ?? 0),
         lastObservedAt: input.chunk.lastObservedAt,
         createdAt: /* @__PURE__ */ new Date(),
         suggestedContinuation: input.chunk.suggestedContinuation,
@@ -5880,8 +7959,8 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       const activatedChunks = chunks.slice(0, chunksToActivate);
       const remainingChunks = chunks.slice(chunksToActivate);
       const activatedContent = activatedChunks.map((c) => c.observations).join("\n\n");
-      const activatedTokens = activatedChunks.reduce((sum, c) => sum + c.tokenCount, 0);
-      const activatedMessageTokens = activatedChunks.reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
+      const activatedTokens = Math.round(activatedChunks.reduce((sum, c) => sum + c.tokenCount, 0));
+      const activatedMessageTokens = Math.round(activatedChunks.reduce((sum, c) => sum + (c.messageTokens ?? 0), 0));
       const activatedMessageCount = activatedChunks.reduce((sum, c) => sum + c.messageIds.length, 0);
       const activatedCycleIds = activatedChunks.map((c) => c.cycleId).filter((id) => !!id);
       const activatedMessageIds = activatedChunks.flatMap((c) => c.messageIds ?? []);
@@ -5968,8 +8047,8 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
         WHERE id = $7`,
         [
           input.reflection,
-          input.tokenCount,
-          input.inputTokenCount,
+          Math.round(input.tokenCount),
+          Math.round(input.inputTokenCount),
           input.reflectedObservationLineCount,
           nowStr,
           nowStr,
@@ -6092,9 +8171,9 @@ var ObservabilityPG = class _ObservabilityPG extends storage.ObservabilityStorag
   }
   /**
    * Returns default index definitions for the observability domain tables.
+   * @param schemaPrefix - Prefix for index names (e.g. "my_schema_" or "")
    */
-  getDefaultIndexDefinitions() {
-    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+  static getDefaultIndexDefs(schemaPrefix) {
     return [
       {
         name: `${schemaPrefix}mastra_ai_spans_traceid_startedat_idx`,
@@ -6156,6 +8235,35 @@ var ObservabilityPG = class _ObservabilityPG extends storage.ObservabilityStorag
       }
     ];
   }
+  /**
+   * Returns all DDL statements for this domain: table, constraints, timestamp trigger, and indexes.
+   * Used by exportSchemas to produce a complete, reproducible schema export.
+   */
+  static getExportDDL(schemaName) {
+    const statements = [];
+    const parsedSchema = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
+    const schemaPrefix = parsedSchema && parsedSchema !== "public" ? `${parsedSchema}_` : "";
+    statements.push(
+      generateTableSQL({
+        tableName: storage.TABLE_SPANS,
+        schema: storage.TABLE_SCHEMAS[storage.TABLE_SPANS],
+        schemaName,
+        includeAllConstraints: true
+      })
+    );
+    statements.push(generateTimestampTriggerSQL(storage.TABLE_SPANS, schemaName));
+    for (const idx of _ObservabilityPG.getDefaultIndexDefs(schemaPrefix)) {
+      statements.push(generateIndexSQL(idx, schemaName));
+    }
+    return statements;
+  }
+  /**
+   * Returns default index definitions for this instance's schema.
+   */
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return _ObservabilityPG.getDefaultIndexDefs(schemaPrefix);
+  }
   /**
    * Creates default indexes for optimal query performance.
    */
@@ -6684,7 +8792,7 @@ var ObservabilityPG = class _ObservabilityPG extends storage.ObservabilityStorag
     }
   }
 };
-var SNAPSHOT_FIELDS = ["name", "description", "content", "rules"];
+var SNAPSHOT_FIELDS2 = ["name", "description", "content", "rules"];
 var PromptBlocksPG = class _PromptBlocksPG extends storage.PromptBlocksStorage {
   #db;
   #schema;
@@ -6699,16 +8807,47 @@ var PromptBlocksPG = class _PromptBlocksPG extends storage.PromptBlocksStorage {
     this.#skipDefaultIndexes = skipDefaultIndexes;
     this.#indexes = indexes?.filter((idx) => _PromptBlocksPG.MANAGED_TABLES.includes(idx.table));
   }
-  getDefaultIndexDefinitions() {
+  /**
+   * Returns default index definitions for the prompt blocks domain tables.
+   * @param schemaPrefix - Prefix for index names (e.g. "my_schema_" or "")
+   */
+  static getDefaultIndexDefs(schemaPrefix) {
     return [
       {
-        name: "idx_prompt_block_versions_block_version",
+        name: `${schemaPrefix}idx_prompt_block_versions_block_version`,
         table: storage.TABLE_PROMPT_BLOCK_VERSIONS,
         columns: ["blockId", "versionNumber"],
         unique: true
       }
     ];
   }
+  /**
+   * Returns all DDL statements for this domain: tables and indexes.
+   * Used by exportSchemas to produce a complete, reproducible schema export.
+   */
+  static getExportDDL(schemaName) {
+    const statements = [];
+    const parsedSchema = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
+    const schemaPrefix = parsedSchema && parsedSchema !== "public" ? `${parsedSchema}_` : "";
+    for (const tableName of _PromptBlocksPG.MANAGED_TABLES) {
+      statements.push(
+        generateTableSQL({
+          tableName,
+          schema: storage.TABLE_SCHEMAS[tableName],
+          schemaName,
+          includeAllConstraints: true
+        })
+      );
+    }
+    for (const idx of _PromptBlocksPG.getDefaultIndexDefs(schemaPrefix)) {
+      statements.push(generateIndexSQL(idx, schemaName));
+    }
+    return statements;
+  }
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return _PromptBlocksPG.getDefaultIndexDefs(schemaPrefix);
+  }
   async createDefaultIndexes() {
     if (this.#skipDefaultIndexes) {
       return;
@@ -6799,7 +8938,7 @@ var PromptBlocksPG = class _PromptBlocksPG extends storage.PromptBlocksStorage {
         blockId: promptBlock.id,
         versionNumber: 1,
         ...snapshotConfig,
-        changedFields: [...SNAPSHOT_FIELDS],
+        changedFields: [...SNAPSHOT_FIELDS2],
         changeMessage: "Initial version"
       });
       return {
@@ -6848,7 +8987,7 @@ var PromptBlocksPG = class _PromptBlocksPG extends storage.PromptBlocksStorage {
       }
       const { authorId, activeVersionId, metadata, status, ...configFields } = updates;
       let versionCreated = false;
-      const hasConfigUpdate = SNAPSHOT_FIELDS.some((field) => field in configFields);
+      const hasConfigUpdate = SNAPSHOT_FIELDS2.some((field) => field in configFields);
       if (hasConfigUpdate) {
         const latestVersion = await this.getLatestVersion(id);
         if (!latestVersion) {
@@ -6870,7 +9009,7 @@ var PromptBlocksPG = class _PromptBlocksPG extends storage.PromptBlocksStorage {
           ...latestConfig
         } = latestVersion;
         const newConfig = { ...latestConfig, ...configFields };
-        const changedFields = SNAPSHOT_FIELDS.filter(
+        const changedFields = SNAPSHOT_FIELDS2.filter(
           (field) => field in configFields && JSON.stringify(configFields[field]) !== JSON.stringify(latestConfig[field])
         );
         if (changedFields.length > 0) {
@@ -7336,7 +9475,7 @@ var PromptBlocksPG = class _PromptBlocksPG extends storage.PromptBlocksStorage {
     };
   }
 };
-var SNAPSHOT_FIELDS2 = [
+var SNAPSHOT_FIELDS3 = [
   "name",
   "description",
   "type",
@@ -7362,16 +9501,47 @@ var ScorerDefinitionsPG = class _ScorerDefinitionsPG extends storage.ScorerDefin
       (idx) => _ScorerDefinitionsPG.MANAGED_TABLES.includes(idx.table)
     );
   }
-  getDefaultIndexDefinitions() {
+  /**
+   * Returns default index definitions for the scorer definitions domain tables.
+   * @param schemaPrefix - Prefix for index names (e.g. "my_schema_" or "")
+   */
+  static getDefaultIndexDefs(schemaPrefix) {
     return [
       {
-        name: "idx_scorer_definition_versions_def_version",
+        name: `${schemaPrefix}idx_scorer_definition_versions_def_version`,
         table: storage.TABLE_SCORER_DEFINITION_VERSIONS,
         columns: ["scorerDefinitionId", "versionNumber"],
         unique: true
       }
     ];
   }
+  /**
+   * Returns all DDL statements for this domain: tables and indexes.
+   * Used by exportSchemas to produce a complete, reproducible schema export.
+   */
+  static getExportDDL(schemaName) {
+    const statements = [];
+    const parsedSchema = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
+    const schemaPrefix = parsedSchema && parsedSchema !== "public" ? `${parsedSchema}_` : "";
+    for (const tableName of _ScorerDefinitionsPG.MANAGED_TABLES) {
+      statements.push(
+        generateTableSQL({
+          tableName,
+          schema: storage.TABLE_SCHEMAS[tableName],
+          schemaName,
+          includeAllConstraints: true
+        })
+      );
+    }
+    for (const idx of _ScorerDefinitionsPG.getDefaultIndexDefs(schemaPrefix)) {
+      statements.push(generateIndexSQL(idx, schemaName));
+    }
+    return statements;
+  }
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return _ScorerDefinitionsPG.getDefaultIndexDefs(schemaPrefix);
+  }
   async createDefaultIndexes() {
     if (this.#skipDefaultIndexes) {
       return;
@@ -7465,7 +9635,7 @@ var ScorerDefinitionsPG = class _ScorerDefinitionsPG extends storage.ScorerDefin
         scorerDefinitionId: scorerDefinition.id,
         versionNumber: 1,
         ...snapshotConfig,
-        changedFields: [...SNAPSHOT_FIELDS2],
+        changedFields: [...SNAPSHOT_FIELDS3],
         changeMessage: "Initial version"
       });
       return {
@@ -7517,7 +9687,7 @@ var ScorerDefinitionsPG = class _ScorerDefinitionsPG extends storage.ScorerDefin
       }
       const { authorId, activeVersionId, metadata, status, ...configFields } = updates;
       let versionCreated = false;
-      const hasConfigUpdate = SNAPSHOT_FIELDS2.some((field) => field in configFields);
+      const hasConfigUpdate = SNAPSHOT_FIELDS3.some((field) => field in configFields);
       if (hasConfigUpdate) {
         const latestVersion = await this.getLatestVersion(id);
         if (!latestVersion) {
@@ -7539,7 +9709,7 @@ var ScorerDefinitionsPG = class _ScorerDefinitionsPG extends storage.ScorerDefin
           ...latestConfig
         } = latestVersion;
         const newConfig = { ...latestConfig, ...configFields };
-        const changedFields = SNAPSHOT_FIELDS2.filter(
+        const changedFields = SNAPSHOT_FIELDS3.filter(
           (field) => field in configFields && JSON.stringify(configFields[field]) !== JSON.stringify(latestConfig[field])
         );
         if (changedFields.length > 0) {
@@ -8058,9 +10228,9 @@ var ScoresPG = class _ScoresPG extends storage.ScoresStorage {
   }
   /**
    * Returns default index definitions for the scores domain tables.
+   * @param schemaPrefix - Prefix for index names (e.g. "my_schema_" or "")
    */
-  getDefaultIndexDefinitions() {
-    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+  static getDefaultIndexDefs(schemaPrefix) {
     return [
       {
         name: `${schemaPrefix}mastra_scores_trace_id_span_id_created_at_idx`,
@@ -8069,6 +10239,34 @@ var ScoresPG = class _ScoresPG extends storage.ScoresStorage {
       }
     ];
   }
+  /**
+   * Returns all DDL statements for this domain: table and indexes.
+   * Used by exportSchemas to produce a complete, reproducible schema export.
+   */
+  static getExportDDL(schemaName) {
+    const statements = [];
+    const parsedSchema = schemaName ? utils.parseSqlIdentifier(schemaName, "schema name") : "";
+    const schemaPrefix = parsedSchema && parsedSchema !== "public" ? `${parsedSchema}_` : "";
+    statements.push(
+      generateTableSQL({
+        tableName: storage.TABLE_SCORERS,
+        schema: storage.TABLE_SCHEMAS[storage.TABLE_SCORERS],
+        schemaName,
+        includeAllConstraints: true
+      })
+    );
+    for (const idx of _ScoresPG.getDefaultIndexDefs(schemaPrefix)) {
+      statements.push(generateIndexSQL(idx, schemaName));
+    }
+    return statements;
+  }
+  /**
+   * Returns default index definitions for this instance's schema.
+   */
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.#schema !== "public" ? `${this.#schema}_` : "";
+    return _ScoresPG.getDefaultIndexDefs(schemaPrefix);
+  }
   /**
    * Creates default indexes for optimal query performance.
    */
@@ -8440,6 +10638,22 @@ var WorkflowsPG = class _WorkflowsPG extends storage.WorkflowsStorage {
       updatedAt: new Date(row.updatedAtZ || row.updatedAt)
     };
   }
+  /**
+   * Returns all DDL statements for this domain: table with unique constraint.
+   * Used by exportSchemas to produce a complete, reproducible schema export.
+   */
+  static getExportDDL(schemaName) {
+    const statements = [];
+    statements.push(
+      generateTableSQL({
+        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+        schema: storage.TABLE_SCHEMAS[storage.TABLE_WORKFLOW_SNAPSHOT],
+        schemaName,
+        includeAllConstraints: true
+      })
+    );
+    return statements;
+  }
   /**
    * Returns default index definitions for the workflows domain tables.
    * Currently no default indexes are defined for workflows.
@@ -8706,6 +10920,29 @@ var WorkflowsPG = class _WorkflowsPG extends storage.WorkflowsStorage {
 // src/storage/index.ts
 var DEFAULT_MAX_CONNECTIONS = 20;
 var DEFAULT_IDLE_TIMEOUT_MS = 3e4;
+var ALL_DOMAINS = [
+  MemoryPG,
+  ObservabilityPG,
+  ScoresPG,
+  ScorerDefinitionsPG,
+  PromptBlocksPG,
+  AgentsPG,
+  WorkflowsPG,
+  DatasetsPG,
+  ExperimentsPG
+];
+function exportSchemas(schemaName) {
+  const statements = [];
+  if (schemaName) {
+    const quotedSchemaName = getSchemaName(schemaName);
+    statements.push(`CREATE SCHEMA IF NOT EXISTS ${quotedSchemaName};`);
+    statements.push("");
+  }
+  for (const Domain of ALL_DOMAINS) {
+    statements.push(...Domain.getExportDDL(schemaName));
+  }
+  return statements.join("\n");
+}
 var PostgresStore = class extends storage.MastraCompositeStore {
   #pool;
   #db;
@@ -8739,7 +10976,10 @@ var PostgresStore = class extends storage.MastraCompositeStore {
         observability: new ObservabilityPG(domainConfig),
         agents: new AgentsPG(domainConfig),
         promptBlocks: new PromptBlocksPG(domainConfig),
-        scorerDefinitions: new ScorerDefinitionsPG(domainConfig)
+        scorerDefinitions: new ScorerDefinitionsPG(domainConfig),
+        mcpClients: new MCPClientsPG(domainConfig),
+        datasets: new DatasetsPG(domainConfig),
+        experiments: new ExperimentsPG(domainConfig)
       };
     } catch (e) {
       throw new error.MastraError(
@@ -8929,6 +11169,9 @@ Example Complex Query:
 }`;
 
 exports.AgentsPG = AgentsPG;
+exports.DatasetsPG = DatasetsPG;
+exports.ExperimentsPG = ExperimentsPG;
+exports.MCPClientsPG = MCPClientsPG;
 exports.MemoryPG = MemoryPG;
 exports.ObservabilityPG = ObservabilityPG;
 exports.PGVECTOR_PROMPT = PGVECTOR_PROMPT;