@mastra/pg 1.5.0 → 1.6.0

package/dist/index.cjs

@@ -5986,6 +5986,648 @@ var MCPClientsPG = class _MCPClientsPG extends storage.MCPClientsStorage {
     };
   }
 };
+var SNAPSHOT_FIELDS2 = [
+  "name",
+  "version",
+  "description",
+  "instructions",
+  "repository",
+  "releaseDate",
+  "isLatest",
+  "packageCanonical",
+  "tools",
+  "agents",
+  "workflows"
+];
+var MCPServersPG = class _MCPServersPG extends storage.MCPServersStorage {
+  #db;
+  #schema;
+  #skipDefaultIndexes;
+  #indexes;
+  static MANAGED_TABLES = [storage.TABLE_MCP_SERVERS, storage.TABLE_MCP_SERVER_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) => _MCPServersPG.MANAGED_TABLES.includes(idx.table));
+  }
+  getDefaultIndexDefinitions() {
+    return [
+      {
+        name: "idx_mcp_server_versions_server_version",
+        table: storage.TABLE_MCP_SERVER_VERSIONS,
+        columns: ["mcpServerId", "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_SERVERS,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_MCP_SERVERS]
+    });
+    await this.#db.createTable({
+      tableName: storage.TABLE_MCP_SERVER_VERSIONS,
+      schema: storage.TABLE_SCHEMAS[storage.TABLE_MCP_SERVER_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_SERVER_VERSIONS });
+    await this.#db.clearTable({ tableName: storage.TABLE_MCP_SERVERS });
+  }
+  // ==========================================================================
+  // MCP Server CRUD Methods
+  // ==========================================================================
+  async getById(id) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_MCP_SERVERS, schemaName: getSchemaName2(this.#schema) });
+      const result = await this.#db.client.oneOrNone(`SELECT * FROM ${tableName} WHERE id = $1`, [id]);
+      if (!result) {
+        return null;
+      }
+      return this.parseMCPServerRow(result);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "GET_MCP_SERVER_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpServerId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async create(input) {
+    const { mcpServer } = input;
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_MCP_SERVERS, 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)`,
+        [
+          mcpServer.id,
+          "draft",
+          null,
+          mcpServer.authorId ?? null,
+          mcpServer.metadata ? JSON.stringify(mcpServer.metadata) : null,
+          nowIso,
+          nowIso,
+          nowIso,
+          nowIso
+        ]
+      );
+      const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = mcpServer;
+      const versionId = crypto.randomUUID();
+      await this.createVersion({
+        id: versionId,
+        mcpServerId: mcpServer.id,
+        versionNumber: 1,
+        ...snapshotConfig,
+        changedFields: [...SNAPSHOT_FIELDS2],
+        changeMessage: "Initial version"
+      });
+      return {
+        id: mcpServer.id,
+        status: "draft",
+        activeVersionId: void 0,
+        authorId: mcpServer.authorId,
+        metadata: mcpServer.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+    } catch (error$1) {
+      try {
+        const tableName = getTableName2({
+          indexName: storage.TABLE_MCP_SERVERS,
+          schemaName: getSchemaName2(this.#schema)
+        });
+        await this.#db.client.none(
+          `DELETE FROM ${tableName} WHERE id = $1 AND status = 'draft' AND "activeVersionId" IS NULL`,
+          [mcpServer.id]
+        );
+      } catch {
+      }
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "CREATE_MCP_SERVER", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpServerId: mcpServer.id }
+        },
+        error$1
+      );
+    }
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_MCP_SERVERS, schemaName: getSchemaName2(this.#schema) });
+      const existingServer = await this.getById(id);
+      if (!existingServer) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("PG", "UPDATE_MCP_SERVER", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: `MCP server ${id} not found`,
+          details: { mcpServerId: id }
+        });
+      }
+      const { authorId, activeVersionId, metadata, status } = updates;
+      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(status);
+      }
+      if (metadata !== void 0) {
+        const mergedMetadata = { ...existingServer.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);
+      await this.#db.client.none(`UPDATE ${tableName} SET ${setClauses.join(", ")} WHERE id = $${paramIndex}`, values);
+      const updatedServer = await this.getById(id);
+      if (!updatedServer) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("PG", "UPDATE_MCP_SERVER", "NOT_FOUND_AFTER_UPDATE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.SYSTEM,
+          text: `MCP server ${id} not found after update`,
+          details: { mcpServerId: id }
+        });
+      }
+      return updatedServer;
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "UPDATE_MCP_SERVER", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpServerId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async delete(id) {
+    try {
+      const tableName = getTableName2({ indexName: storage.TABLE_MCP_SERVERS, 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_SERVER", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpServerId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async list(args) {
+    const { page = 0, perPage: perPageInput, orderBy, authorId, metadata, status = "published" } = args || {};
+    const { field, direction } = this.parseOrderBy(orderBy);
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "LIST_MCP_SERVERS", "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_SERVERS, schemaName: getSchemaName2(this.#schema) });
+      const conditions = [];
+      const queryParams = [];
+      let paramIdx = 1;
+      conditions.push(`status = $${paramIdx++}`);
+      queryParams.push(status);
+      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 = `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 {
+          mcpServers: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const dataResult = await this.#db.client.manyOrNone(
+        `SELECT * FROM ${tableName} ${whereClause} ORDER BY "${field}" ${direction} LIMIT $${paramIdx++} OFFSET $${paramIdx++}`,
+        [...queryParams, limitValue, offset]
+      );
+      const mcpServers = (dataResult || []).map((row) => this.parseMCPServerRow(row));
+      return {
+        mcpServers,
+        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_MCP_SERVERS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // MCP Server Version Methods
+  // ==========================================================================
+  async createVersion(input) {
+    try {
+      const tableName = getTableName2({
+        indexName: storage.TABLE_MCP_SERVER_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const now = /* @__PURE__ */ new Date();
+      const nowIso = now.toISOString();
+      await this.#db.client.none(
+        `INSERT INTO ${tableName} (
+          id, "mcpServerId", "versionNumber",
+          name, version, description, instructions,
+          repository, "releaseDate", "isLatest", "packageCanonical",
+          tools, agents, workflows,
+          "changedFields", "changeMessage",
+          "createdAt", "createdAtZ"
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18)`,
+        [
+          input.id,
+          input.mcpServerId,
+          input.versionNumber,
+          input.name,
+          input.version,
+          input.description ?? null,
+          input.instructions ?? null,
+          input.repository ? JSON.stringify(input.repository) : null,
+          input.releaseDate ?? null,
+          input.isLatest ?? null,
+          input.packageCanonical ?? null,
+          input.tools ? JSON.stringify(input.tools) : null,
+          input.agents ? JSON.stringify(input.agents) : null,
+          input.workflows ? JSON.stringify(input.workflows) : 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_MCP_SERVER_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: input.id, mcpServerId: input.mcpServerId }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersion(id) {
+    try {
+      const tableName = getTableName2({
+        indexName: storage.TABLE_MCP_SERVER_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_MCP_SERVER_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error$1
+      );
+    }
+  }
+  async getVersionByNumber(mcpServerId, versionNumber) {
+    try {
+      const tableName = getTableName2({
+        indexName: storage.TABLE_MCP_SERVER_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const result = await this.#db.client.oneOrNone(
+        `SELECT * FROM ${tableName} WHERE "mcpServerId" = $1 AND "versionNumber" = $2`,
+        [mcpServerId, 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_MCP_SERVER_VERSION_BY_NUMBER", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpServerId, versionNumber }
+        },
+        error$1
+      );
+    }
+  }
+  async getLatestVersion(mcpServerId) {
+    try {
+      const tableName = getTableName2({
+        indexName: storage.TABLE_MCP_SERVER_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const result = await this.#db.client.oneOrNone(
+        `SELECT * FROM ${tableName} WHERE "mcpServerId" = $1 ORDER BY "versionNumber" DESC LIMIT 1`,
+        [mcpServerId]
+      );
+      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_MCP_SERVER_VERSION", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpServerId }
+        },
+        error$1
+      );
+    }
+  }
+  async listVersions(input) {
+    const { mcpServerId, page = 0, perPage: perPageInput, orderBy } = input;
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "LIST_MCP_SERVER_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_MCP_SERVER_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const countResult = await this.#db.client.one(
+        `SELECT COUNT(*) as count FROM ${tableName} WHERE "mcpServerId" = $1`,
+        [mcpServerId]
+      );
+      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 "mcpServerId" = $1 ORDER BY "${field}" ${direction} LIMIT $2 OFFSET $3`,
+        [mcpServerId, 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_MCP_SERVER_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpServerId }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteVersion(id) {
+    try {
+      const tableName = getTableName2({
+        indexName: storage.TABLE_MCP_SERVER_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_MCP_SERVER_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_MCP_SERVER_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      await this.#db.client.none(`DELETE FROM ${tableName} WHERE "mcpServerId" = $1`, [entityId]);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("PG", "DELETE_MCP_SERVER_VERSIONS_BY_MCP_SERVER_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpServerId: entityId }
+        },
+        error$1
+      );
+    }
+  }
+  async countVersions(mcpServerId) {
+    try {
+      const tableName = getTableName2({
+        indexName: storage.TABLE_MCP_SERVER_VERSIONS,
+        schemaName: getSchemaName2(this.#schema)
+      });
+      const result = await this.#db.client.one(`SELECT COUNT(*) as count FROM ${tableName} WHERE "mcpServerId" = $1`, [
+        mcpServerId
+      ]);
+      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_MCP_SERVER_VERSIONS", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { mcpServerId }
+        },
+        error$1
+      );
+    }
+  }
+  // ==========================================================================
+  // Private Helper Methods
+  // ==========================================================================
+  parseJson(value, fieldName) {
+    if (!value) return void 0;
+    if (typeof value !== "string") return value;
+    try {
+      return JSON.parse(value);
+    } catch (error$1) {
+      if (error$1 instanceof error.MastraError) throw error$1;
+      const details = {
+        valueLength: String(value.length)
+      };
+      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
+      );
+    }
+  }
+  parseMCPServerRow(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,
+      mcpServerId: row.mcpServerId,
+      versionNumber: row.versionNumber,
+      name: row.name,
+      version: row.version,
+      description: row.description,
+      instructions: row.instructions,
+      repository: this.parseJson(row.repository, "repository"),
+      releaseDate: row.releaseDate,
+      isLatest: row.isLatest,
+      packageCanonical: row.packageCanonical,
+      tools: this.parseJson(row.tools, "tools"),
+      agents: this.parseJson(row.agents, "agents"),
+      workflows: this.parseJson(row.workflows, "workflows"),
+      changedFields: this.parseJson(row.changedFields, "changedFields"),
+      changeMessage: row.changeMessage,
+      createdAt: new Date(row.createdAtZ || row.createdAt)
+    };
+  }
+};
 var OM_TABLE = "mastra_observational_memory";
 var _omTableSchema;
 try {
@@ -7930,32 +8572,39 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
       const targetMessageTokens = Math.max(0, input.currentPendingTokens - retentionFloor);
       let cumulativeMessageTokens = 0;
       let chunksToActivate = 0;
-      let bestBoundary = 0;
-      let bestBoundaryMessageTokens = 0;
+      let bestOverBoundary = 0;
+      let bestOverTokens = 0;
+      let bestUnderBoundary = 0;
+      let bestUnderTokens = 0;
       for (let i = 0; i < chunks.length; i++) {
         cumulativeMessageTokens += chunks[i].messageTokens ?? 0;
         const boundary = i + 1;
-        const isUnder = cumulativeMessageTokens <= targetMessageTokens;
-        const bestIsUnder = bestBoundaryMessageTokens <= targetMessageTokens;
-        if (bestBoundary === 0) {
-          bestBoundary = boundary;
-          bestBoundaryMessageTokens = cumulativeMessageTokens;
-        } else if (isUnder && !bestIsUnder) {
-          bestBoundary = boundary;
-          bestBoundaryMessageTokens = cumulativeMessageTokens;
-        } else if (isUnder && bestIsUnder) {
-          if (cumulativeMessageTokens > bestBoundaryMessageTokens) {
-            bestBoundary = boundary;
-            bestBoundaryMessageTokens = cumulativeMessageTokens;
+        if (cumulativeMessageTokens >= targetMessageTokens) {
+          if (bestOverBoundary === 0 || cumulativeMessageTokens < bestOverTokens) {
+            bestOverBoundary = boundary;
+            bestOverTokens = cumulativeMessageTokens;
           }
-        } else if (!isUnder && !bestIsUnder) {
-          if (cumulativeMessageTokens < bestBoundaryMessageTokens) {
-            bestBoundary = boundary;
-            bestBoundaryMessageTokens = cumulativeMessageTokens;
+        } else {
+          if (cumulativeMessageTokens > bestUnderTokens) {
+            bestUnderBoundary = boundary;
+            bestUnderTokens = cumulativeMessageTokens;
           }
         }
       }
-      chunksToActivate = bestBoundary === 0 ? 1 : bestBoundary;
+      const maxOvershoot = retentionFloor * 0.95;
+      const overshoot = bestOverTokens - targetMessageTokens;
+      const remainingAfterOver = input.currentPendingTokens - bestOverTokens;
+      if (input.forceMaxActivation && bestOverBoundary > 0) {
+        chunksToActivate = bestOverBoundary;
+      } else if (bestOverBoundary > 0 && overshoot <= maxOvershoot && (remainingAfterOver >= 1e3 || retentionFloor === 0)) {
+        chunksToActivate = bestOverBoundary;
+      } else if (bestUnderBoundary > 0) {
+        chunksToActivate = bestUnderBoundary;
+      } else if (bestOverBoundary > 0) {
+        chunksToActivate = bestOverBoundary;
+      } else {
+        chunksToActivate = 1;
+      }
       const activatedChunks = chunks.slice(0, chunksToActivate);
       const remainingChunks = chunks.slice(chunksToActivate);
       const activatedContent = activatedChunks.map((c) => c.observations).join("\n\n");
@@ -7994,6 +8643,7 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
           input.id
         ]
       );
+      const latestChunkHints = activatedChunks[activatedChunks.length - 1];
       return {
         chunksActivated: activatedChunks.length,
         messageTokensActivated: activatedMessageTokens,
@@ -8008,7 +8658,9 @@ var MemoryPG = class _MemoryPG extends storage.MemoryStorage {
           observationTokens: c.tokenCount,
           messageCount: c.messageIds.length,
           observations: c.observations
-        }))
+        })),
+        suggestedContinuation: latestChunkHints?.suggestedContinuation ?? void 0,
+        currentTask: latestChunkHints?.currentTask ?? void 0
       };
     } catch (error$1) {
       if (error$1 instanceof error.MastraError) {
@@ -8792,7 +9444,7 @@ var ObservabilityPG = class _ObservabilityPG extends storage.ObservabilityStorag
     }
   }
 };
-var SNAPSHOT_FIELDS2 = ["name", "description", "content", "rules"];
+var SNAPSHOT_FIELDS3 = ["name", "description", "content", "rules"];
 var PromptBlocksPG = class _PromptBlocksPG extends storage.PromptBlocksStorage {
   #db;
   #schema;
@@ -8938,7 +9590,7 @@ var PromptBlocksPG = class _PromptBlocksPG extends storage.PromptBlocksStorage {
         blockId: promptBlock.id,
         versionNumber: 1,
         ...snapshotConfig,
-        changedFields: [...SNAPSHOT_FIELDS2],
+        changedFields: [...SNAPSHOT_FIELDS3],
         changeMessage: "Initial version"
       });
       return {
@@ -9429,7 +10081,7 @@ var PromptBlocksPG = class _PromptBlocksPG extends storage.PromptBlocksStorage {
     };
   }
 };
-var SNAPSHOT_FIELDS3 = [
+var SNAPSHOT_FIELDS4 = [
   "name",
   "description",
   "type",
@@ -9589,7 +10241,7 @@ var ScorerDefinitionsPG = class _ScorerDefinitionsPG extends storage.ScorerDefin
         scorerDefinitionId: scorerDefinition.id,
         versionNumber: 1,
         ...snapshotConfig,
-        changedFields: [...SNAPSHOT_FIELDS3],
+        changedFields: [...SNAPSHOT_FIELDS4],
         changeMessage: "Initial version"
       });
       return {
@@ -10505,7 +11157,7 @@ var ScoresPG = class _ScoresPG extends storage.ScoresStorage {
     }
   }
 };
-var SNAPSHOT_FIELDS4 = [
+var SNAPSHOT_FIELDS5 = [
   "name",
   "description",
   "instructions",
@@ -10625,7 +11277,7 @@ var SkillsPG = class _SkillsPG extends storage.SkillsStorage {
         skillId: skill.id,
         versionNumber: 1,
         ...snapshotConfig,
-        changedFields: [...SNAPSHOT_FIELDS4],
+        changedFields: [...SNAPSHOT_FIELDS5],
         changeMessage: "Initial version"
       });
       return {
@@ -10676,7 +11328,7 @@ var SkillsPG = class _SkillsPG extends storage.SkillsStorage {
       }
       const { authorId, activeVersionId, status, ...configFields } = updates;
       let versionCreated = false;
-      const hasConfigUpdate = SNAPSHOT_FIELDS4.some((field) => field in configFields);
+      const hasConfigUpdate = SNAPSHOT_FIELDS5.some((field) => field in configFields);
       if (hasConfigUpdate) {
         const latestVersion = await this.getLatestVersion(id);
         if (!latestVersion) {
@@ -10698,7 +11350,7 @@ var SkillsPG = class _SkillsPG extends storage.SkillsStorage {
           ...latestConfig
         } = latestVersion;
         const newConfig = { ...latestConfig, ...configFields };
-        const changedFields = SNAPSHOT_FIELDS4.filter(
+        const changedFields = SNAPSHOT_FIELDS5.filter(
           (field) => field in configFields && JSON.stringify(configFields[field]) !== JSON.stringify(latestConfig[field])
         );
         if (changedFields.length > 0) {
@@ -11491,7 +12143,7 @@ var WorkflowsPG = class _WorkflowsPG extends storage.WorkflowsStorage {
     }
   }
 };
-var SNAPSHOT_FIELDS5 = [
+var SNAPSHOT_FIELDS6 = [
   "name",
   "description",
   "filesystem",
@@ -11620,7 +12272,7 @@ var WorkspacesPG = class _WorkspacesPG extends storage.WorkspacesStorage {
         workspaceId: workspace.id,
         versionNumber: 1,
         ...snapshotConfig,
-        changedFields: [...SNAPSHOT_FIELDS5],
+        changedFields: [...SNAPSHOT_FIELDS6],
         changeMessage: "Initial version"
       });
       return {
@@ -11672,7 +12324,7 @@ var WorkspacesPG = class _WorkspacesPG extends storage.WorkspacesStorage {
       }
       const { authorId, activeVersionId, metadata, status, ...configFields } = updates;
       let versionCreated = false;
-      const hasConfigUpdate = SNAPSHOT_FIELDS5.some((field) => field in configFields);
+      const hasConfigUpdate = SNAPSHOT_FIELDS6.some((field) => field in configFields);
       if (hasConfigUpdate) {
         const latestVersion = await this.getLatestVersion(id);
         if (!latestVersion) {
@@ -11694,7 +12346,7 @@ var WorkspacesPG = class _WorkspacesPG extends storage.WorkspacesStorage {
           ...latestConfig
         } = latestVersion;
         const newConfig = { ...latestConfig, ...configFields };
-        const changedFields = SNAPSHOT_FIELDS5.filter(
+        const changedFields = SNAPSHOT_FIELDS6.filter(
           (field) => field in configFields && JSON.stringify(configFields[field]) !== JSON.stringify(latestConfig[field])
         );
         if (changedFields.length > 0) {
@@ -12237,6 +12889,7 @@ var PostgresStore = class extends storage.MastraCompositeStore {
         promptBlocks: new PromptBlocksPG(domainConfig),
         scorerDefinitions: new ScorerDefinitionsPG(domainConfig),
         mcpClients: new MCPClientsPG(domainConfig),
+        mcpServers: new MCPServersPG(domainConfig),
         workspaces: new WorkspacesPG(domainConfig),
         skills: new SkillsPG(domainConfig),
         blobs: new BlobsPG(domainConfig),
@@ -12435,6 +13088,7 @@ exports.BlobsPG = BlobsPG;
 exports.DatasetsPG = DatasetsPG;
 exports.ExperimentsPG = ExperimentsPG;
 exports.MCPClientsPG = MCPClientsPG;
+exports.MCPServersPG = MCPServersPG;
 exports.MemoryPG = MemoryPG;
 exports.ObservabilityPG = ObservabilityPG;
 exports.PGVECTOR_PROMPT = PGVECTOR_PROMPT;