@mastra/pg 0.17.8 → 1.0.0-beta.0

package/dist/index.cjs

@@ -10,7 +10,7 @@ var filter = require('@mastra/core/vector/filter');
 var storage = require('@mastra/core/storage');
 var pgPromise = require('pg-promise');
 var agent = require('@mastra/core/agent');
-var scores = require('@mastra/core/scores');
+var evals = require('@mastra/core/evals');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -49,6 +49,9 @@ var isCloudSqlConfig = (cfg) => {
   return "stream" in cfg || "password" in cfg && typeof cfg.password === "function";
 };
 var validateConfig = (name, config) => {
+  if (!config.id || typeof config.id !== "string" || config.id.trim() === "") {
+    throw new Error(`${name}: id must be provided and cannot be empty.`);
+  }
   if (isConnectionStringConfig(config)) {
     if (!config.connectionString || typeof config.connectionString !== "string" || config.connectionString.trim() === "") {
       throw new Error(
@@ -429,7 +432,7 @@ var PgVector = class extends vector.MastraVector {
   constructor(config) {
     try {
       validateConfig("PgVector", config);
-      super();
+      super({ id: config.id });
       this.schema = config.schemaName;
       let poolConfig;
       if (isConnectionStringConfig(config)) {
@@ -465,14 +468,7 @@ var PgVector = class extends vector.MastraVector {
       } else {
         throw new Error("PgVector: invalid configuration provided");
       }
-      const basePool = new pg__namespace.Pool(poolConfig);
-      const telemetry = this.__getTelemetry();
-      this.pool = telemetry?.traceClass(basePool, {
-        spanNamePrefix: "pg-vector",
-        attributes: {
-          "vector.type": "postgres"
-        }
-      }) ?? basePool;
+      this.pool = new pg__namespace.Pool(poolConfig);
       this.cacheWarmupPromise = (async () => {
         try {
           const existingIndexes = await this.listIndexes();
@@ -749,7 +745,7 @@ var PgVector = class extends vector.MastraVector {
           const schemaCheck = await client.query(
             `
             SELECT EXISTS (
-              SELECT 1 FROM information_schema.schemata 
+              SELECT 1 FROM information_schema.schemata
               WHERE schema_name = $1
             )
           `,
@@ -946,8 +942,8 @@ var PgVector = class extends vector.MastraVector {
         const m = indexConfig.hnsw?.m ?? 8;
         const efConstruction = indexConfig.hnsw?.efConstruction ?? 32;
         indexSQL = `
-          CREATE INDEX IF NOT EXISTS ${vectorIndexName} 
-          ON ${tableName} 
+          CREATE INDEX IF NOT EXISTS ${vectorIndexName}
+          ON ${tableName}
           USING hnsw (embedding ${metricOp})
           WITH (
             m = ${m},
@@ -1398,123 +1394,7 @@ function transformFromSqlRow({
   return result;
 }
 
-// src/storage/domains/legacy-evals/index.ts
-function transformEvalRow(row) {
-  let testInfoValue = null;
-  if (row.test_info) {
-    try {
-      testInfoValue = typeof row.test_info === "string" ? JSON.parse(row.test_info) : row.test_info;
-    } catch (e) {
-      console.warn("Failed to parse test_info:", e);
-    }
-  }
-  return {
-    agentName: row.agent_name,
-    input: row.input,
-    output: row.output,
-    result: row.result,
-    metricName: row.metric_name,
-    instructions: row.instructions,
-    testInfo: testInfoValue,
-    globalRunId: row.global_run_id,
-    runId: row.run_id,
-    createdAt: row.created_atZ || row.created_at
-  };
-}
-var LegacyEvalsPG = class extends storage.LegacyEvalsStorage {
-  client;
-  schema;
-  constructor({ client, schema }) {
-    super();
-    this.client = client;
-    this.schema = schema;
-  }
-  /** @deprecated use getEvals instead */
-  async getEvalsByAgentName(agentName, type) {
-    try {
-      const baseQuery = `SELECT * FROM ${getTableName({ indexName: storage.TABLE_EVALS, schemaName: getSchemaName(this.schema) })} WHERE agent_name = $1`;
-      const typeCondition = type === "test" ? " AND test_info IS NOT NULL AND test_info->>'testPath' IS NOT NULL" : type === "live" ? " AND (test_info IS NULL OR test_info->>'testPath' IS NULL)" : "";
-      const query = `${baseQuery}${typeCondition} ORDER BY created_at DESC`;
-      const rows = await this.client.manyOrNone(query, [agentName]);
-      return rows?.map((row) => transformEvalRow(row)) ?? [];
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("relation") && error.message.includes("does not exist")) {
-        return [];
-      }
-      console.error("Failed to get evals for the specified agent: " + error?.message);
-      throw error;
-    }
-  }
-  async getEvals(options = {}) {
-    const tableName = getTableName({ indexName: storage.TABLE_EVALS, schemaName: getSchemaName(this.schema) });
-    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-    const conditions = [];
-    const queryParams = [];
-    let paramIndex = 1;
-    if (agentName) {
-      conditions.push(`agent_name = $${paramIndex++}`);
-      queryParams.push(agentName);
-    }
-    if (type === "test") {
-      conditions.push(`(test_info IS NOT NULL AND test_info->>'testPath' IS NOT NULL)`);
-    } else if (type === "live") {
-      conditions.push(`(test_info IS NULL OR test_info->>'testPath' IS NULL)`);
-    }
-    if (fromDate) {
-      conditions.push(`created_at >= $${paramIndex++}`);
-      queryParams.push(fromDate);
-    }
-    if (toDate) {
-      conditions.push(`created_at <= $${paramIndex++}`);
-      queryParams.push(toDate);
-    }
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    const countQuery = `SELECT COUNT(*) FROM ${tableName} ${whereClause}`;
-    try {
-      const countResult = await this.client.one(countQuery, queryParams);
-      const total = parseInt(countResult.count, 10);
-      const currentOffset = page * perPage;
-      if (total === 0) {
-        return {
-          evals: [],
-          total: 0,
-          page,
-          perPage,
-          hasMore: false
-        };
-      }
-      const dataQuery = `SELECT * FROM ${tableName} ${whereClause} ORDER BY created_at DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
-      const rows = await this.client.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
-      return {
-        evals: rows?.map((row) => transformEvalRow(row)) ?? [],
-        total,
-        page,
-        perPage,
-        hasMore: currentOffset + (rows?.length ?? 0) < total
-      };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_PG_STORE_GET_EVALS_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            agentName: agentName || "all",
-            type: type || "all",
-            page,
-            perPage
-          }
-        },
-        error$1
-      );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      throw mastraError;
-    }
-  }
-};
+// src/storage/domains/memory/index.ts
 var MemoryPG = class extends storage.MemoryStorage {
   client;
   schema;
@@ -1575,40 +1455,27 @@ var MemoryPG = class extends storage.MemoryStorage {
       );
     }
   }
-  /**
-   * @deprecated use getThreadsByResourceIdPaginated instead
-   */
-  async getThreadsByResourceId(args) {
-    const resourceId = args.resourceId;
-    const orderBy = this.castThreadOrderBy(args.orderBy);
-    const sortDirection = this.castThreadSortDirection(args.sortDirection);
-    try {
-      const tableName = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
-      const baseQuery = `FROM ${tableName} WHERE "resourceId" = $1`;
-      const queryParams = [resourceId];
-      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "${orderBy}" ${sortDirection}`;
-      const rows = await this.client.manyOrNone(dataQuery, queryParams);
-      return (rows || []).map((thread) => ({
-        ...thread,
-        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-        createdAt: thread.createdAt,
-        updatedAt: thread.updatedAt
-      }));
-    } catch (error) {
-      this.logger.error(`Error getting threads for resource ${resourceId}:`, error);
-      return [];
+  async listThreadsByResourceId(args) {
+    const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
+    if (page < 0) {
+      throw new error.MastraError({
+        id: "MASTRA_STORAGE_PG_STORE_INVALID_PAGE",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: "Page number must be non-negative",
+        details: {
+          resourceId,
+          page
+        }
+      });
     }
-  }
-  async getThreadsByResourceIdPaginated(args) {
-    const { resourceId, page = 0, perPage: perPageInput } = args;
-    const orderBy = this.castThreadOrderBy(args.orderBy);
-    const sortDirection = this.castThreadSortDirection(args.sortDirection);
+    const { field, direction } = this.parseOrderBy(orderBy);
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
     try {
       const tableName = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
       const baseQuery = `FROM ${tableName} WHERE "resourceId" = $1`;
       const queryParams = [resourceId];
-      const perPage = perPageInput !== void 0 ? perPageInput : 100;
-      const currentOffset = page * perPage;
       const countQuery = `SELECT COUNT(*) ${baseQuery}`;
       const countResult = await this.client.one(countQuery, queryParams);
       const total = parseInt(countResult.count, 10);
@@ -1617,12 +1484,13 @@ var MemoryPG = class extends storage.MemoryStorage {
           threads: [],
           total: 0,
           page,
-          perPage,
+          perPage: perPageForResponse,
           hasMore: false
         };
       }
-      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "${orderBy}" ${sortDirection} LIMIT $2 OFFSET $3`;
-      const rows = await this.client.manyOrNone(dataQuery, [...queryParams, perPage, currentOffset]);
+      const limitValue = perPageInput === false ? total : perPage;
+      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "${field}" ${direction} LIMIT $2 OFFSET $3`;
+      const rows = await this.client.manyOrNone(dataQuery, [...queryParams, limitValue, offset]);
       const threads = (rows || []).map((thread) => ({
         ...thread,
         metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
@@ -1634,13 +1502,13 @@ var MemoryPG = class extends storage.MemoryStorage {
         threads,
         total,
         page,
-        perPage,
-        hasMore: currentOffset + threads.length < total
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
       };
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_LIST_THREADS_BY_RESOURCE_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
@@ -1652,7 +1520,13 @@ var MemoryPG = class extends storage.MemoryStorage {
       );
       this.logger?.error?.(mastraError.toString());
       this.logger?.trackException(mastraError);
-      return { threads: [], total: 0, page, perPage: perPageInput || 100, hasMore: false };
+      return {
+        threads: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
     }
   }
   async saveThread({ thread }) {
@@ -1786,11 +1660,9 @@ var MemoryPG = class extends storage.MemoryStorage {
   }
   async _getIncludedMessages({
     threadId,
-    selectBy,
-    orderByStatement
+    include
   }) {
     if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-    const include = selectBy?.include;
     if (!include) return null;
     const unionQueries = [];
     const params = [];
@@ -1805,7 +1677,7 @@ var MemoryPG = class extends storage.MemoryStorage {
               WITH ordered_messages AS (
                 SELECT 
                   *,
-                  ROW_NUMBER() OVER (${orderByStatement}) as row_num
+                  ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
                 FROM ${tableName}
                 WHERE thread_id = $${paramIdx}
               )
@@ -1824,11 +1696,11 @@ var MemoryPG = class extends storage.MemoryStorage {
                 SELECT 1 FROM ordered_messages target
                 WHERE target.id = $${paramIdx + 1}
                 AND (
-                  -- Get previous messages based on the max withPreviousMessages
-                  (m.row_num <= target.row_num + $${paramIdx + 2} AND m.row_num > target.row_num)
+                  -- Get previous messages (messages that come BEFORE the target)
+                  (m.row_num < target.row_num AND m.row_num >= target.row_num - $${paramIdx + 2})
                   OR
-                  -- Get next messages based on the max withNextMessages
-                  (m.row_num >= target.row_num - $${paramIdx + 3} AND m.row_num < target.row_num)
+                  -- Get next messages (messages that come AFTER the target)
+                  (m.row_num > target.row_num AND m.row_num <= target.row_num + $${paramIdx + 3})
                 )
               )
             ) AS query_${paramIdx}
@@ -1865,72 +1737,8 @@ var MemoryPG = class extends storage.MemoryStorage {
       ...normalized.type && normalized.type !== "v2" ? { type: normalized.type } : {}
     };
   }
-  async getMessages(args) {
-    const { threadId, resourceId, format, selectBy } = args;
-    const selectStatement = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
-    const orderByStatement = `ORDER BY "createdAt" DESC`;
-    const limit = storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
-    try {
-      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-      let rows = [];
-      const include = selectBy?.include || [];
-      if (include?.length) {
-        const includeMessages = await this._getIncludedMessages({ threadId, selectBy, orderByStatement });
-        if (includeMessages) {
-          rows.push(...includeMessages);
-        }
-      }
-      const excludeIds = rows.map((m) => m.id);
-      const tableName = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
-      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + 2}`).join(", ");
-      let query = `${selectStatement} FROM ${tableName} WHERE thread_id = $1 
-        ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ""}
-        ${orderByStatement}
-        LIMIT $${excludeIds.length + 2}
-        `;
-      const queryParams = [threadId, ...excludeIds, limit];
-      const remainingRows = await this.client.manyOrNone(query, queryParams);
-      rows.push(...remainingRows);
-      const fetchedMessages = (rows || []).map((row) => {
-        const message = this.normalizeMessageRow(row);
-        if (typeof message.content === "string") {
-          try {
-            message.content = JSON.parse(message.content);
-          } catch {
-          }
-        }
-        if (message.type === "v2") delete message.type;
-        return message;
-      });
-      const sortedMessages = fetchedMessages.sort(
-        (a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime()
-      );
-      return format === "v2" ? sortedMessages.map(
-        (m) => ({ ...m, content: m.content || { format: 2, parts: [{ type: "text", text: "" }] } })
-      ) : sortedMessages;
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_PG_STORE_GET_MESSAGES_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId,
-            resourceId: resourceId ?? ""
-          }
-        },
-        error$1
-      );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      return [];
-    }
-  }
-  async getMessagesById({
-    messageIds,
-    format
-  }) {
-    if (messageIds.length === 0) return [];
+  async listMessagesById({ messageIds }) {
+    if (messageIds.length === 0) return { messages: [] };
     const selectStatement = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
     try {
       const tableName = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
@@ -1944,12 +1752,11 @@ var MemoryPG = class extends storage.MemoryStorage {
         resultRows.map((row) => this.parseRow(row)),
         "memory"
       );
-      if (format === `v1`) return list.get.all.v1();
-      return list.get.all.v2();
+      return { messages: list.get.all.db() };
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_GET_MESSAGES_BY_ID_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_LIST_MESSAGES_BY_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
@@ -1960,102 +1767,138 @@ var MemoryPG = class extends storage.MemoryStorage {
       );
       this.logger?.error?.(mastraError.toString());
       this.logger?.trackException(mastraError);
-      return [];
+      return { messages: [] };
     }
   }
-  async getMessagesPaginated(args) {
-    const { threadId, resourceId, format, selectBy } = args;
-    const { page = 0, perPage: perPageInput, dateRange } = selectBy?.pagination || {};
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-    const selectStatement = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
-    const orderByStatement = `ORDER BY "createdAt" DESC`;
-    const messages = [];
-    try {
-      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-      if (selectBy?.include?.length) {
-        const includeMessages = await this._getIncludedMessages({ threadId, selectBy, orderByStatement });
-        if (includeMessages) {
-          messages.push(...includeMessages);
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    if (!threadId.trim()) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_PG_LIST_MESSAGES_INVALID_THREAD_ID",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        new Error("threadId must be a non-empty string")
+      );
+    }
+    if (page < 0) {
+      throw new error.MastraError({
+        id: "MASTRA_STORAGE_PG_STORE_INVALID_PAGE",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: "Page number must be non-negative",
+        details: {
+          threadId,
+          page
         }
-      }
-      const perPage = perPageInput !== void 0 ? perPageInput : storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
-      const currentOffset = page * perPage;
+      });
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    try {
+      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+      const orderByStatement = `ORDER BY "${field}" ${direction}`;
+      const selectStatement = `SELECT id, content, role, type, "createdAt", "createdAtZ", thread_id AS "threadId", "resourceId"`;
+      const tableName = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
       const conditions = [`thread_id = $1`];
       const queryParams = [threadId];
       let paramIndex = 2;
-      if (fromDate) {
+      if (resourceId) {
+        conditions.push(`"resourceId" = $${paramIndex++}`);
+        queryParams.push(resourceId);
+      }
+      if (filter?.dateRange?.start) {
         conditions.push(`"createdAt" >= $${paramIndex++}`);
-        queryParams.push(fromDate);
+        queryParams.push(filter.dateRange.start);
       }
-      if (toDate) {
+      if (filter?.dateRange?.end) {
         conditions.push(`"createdAt" <= $${paramIndex++}`);
-        queryParams.push(toDate);
+        queryParams.push(filter.dateRange.end);
       }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-      const tableName = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
       const countQuery = `SELECT COUNT(*) FROM ${tableName} ${whereClause}`;
       const countResult = await this.client.one(countQuery, queryParams);
       const total = parseInt(countResult.count, 10);
-      if (total === 0 && messages.length === 0) {
+      const limitValue = perPageInput === false ? total : perPage;
+      const dataQuery = `${selectStatement} FROM ${tableName} ${whereClause} ${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
+      const rows = await this.client.manyOrNone(dataQuery, [...queryParams, limitValue, offset]);
+      const messages = [...rows || []];
+      if (total === 0 && messages.length === 0 && (!include || include.length === 0)) {
         return {
           messages: [],
           total: 0,
           page,
-          perPage,
+          perPage: perPageForResponse,
           hasMore: false
         };
       }
-      const excludeIds = messages.map((m) => m.id);
-      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + paramIndex}`).join(", ");
-      paramIndex += excludeIds.length;
-      const dataQuery = `${selectStatement} FROM ${tableName} ${whereClause} ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ""}${orderByStatement} LIMIT $${paramIndex++} OFFSET $${paramIndex++}`;
-      const rows = await this.client.manyOrNone(dataQuery, [...queryParams, ...excludeIds, perPage, currentOffset]);
-      messages.push(...rows || []);
-      const messagesWithParsedContent = messages.map((row) => {
-        const message = this.normalizeMessageRow(row);
-        if (typeof message.content === "string") {
-          try {
-            return { ...message, content: JSON.parse(message.content) };
-          } catch {
-            return message;
+      const messageIds = new Set(messages.map((m) => m.id));
+      if (include && include.length > 0) {
+        const includeMessages = await this._getIncludedMessages({ threadId, include });
+        if (includeMessages) {
+          for (const includeMsg of includeMessages) {
+            if (!messageIds.has(includeMsg.id)) {
+              messages.push(includeMsg);
+              messageIds.add(includeMsg.id);
+            }
           }
         }
-        return message;
-      });
+      }
+      const messagesWithParsedContent = messages.map((row) => this.parseRow(row));
       const list = new agent.MessageList().add(messagesWithParsedContent, "memory");
-      const messagesToReturn = format === `v2` ? list.get.all.v2() : list.get.all.v1();
+      let finalMessages = list.get.all.db();
+      finalMessages = finalMessages.sort((a, b) => {
+        const aValue = field === "createdAt" ? new Date(a.createdAt).getTime() : a[field];
+        const bValue = field === "createdAt" ? new Date(b.createdAt).getTime() : b[field];
+        if (aValue == null && bValue == null) return a.id.localeCompare(b.id);
+        if (aValue == null) return 1;
+        if (bValue == null) return -1;
+        if (aValue === bValue) {
+          return a.id.localeCompare(b.id);
+        }
+        if (typeof aValue === "number" && typeof bValue === "number") {
+          return direction === "ASC" ? aValue - bValue : bValue - aValue;
+        }
+        return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
+      });
+      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
+      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
+      const hasMore = perPageInput !== false && !allThreadMessagesReturned && offset + perPage < total;
       return {
-        messages: messagesToReturn,
+        messages: finalMessages,
         total,
         page,
-        perPage,
-        hasMore: currentOffset + rows.length < total
+        perPage: perPageForResponse,
+        hasMore
       };
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_GET_MESSAGES_PAGINATED_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_LIST_MESSAGES_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
             threadId,
-            resourceId: resourceId ?? "",
-            page
+            resourceId: resourceId ?? ""
           }
         },
         error$1
       );
       this.logger?.error?.(mastraError.toString());
       this.logger?.trackException(mastraError);
-      return { messages: [], total: 0, page, perPage: perPageInput || 40, hasMore: false };
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
     }
   }
-  async saveMessages({
-    messages,
-    format
-  }) {
-    if (messages.length === 0) return messages;
+  async saveMessages({ messages }) {
+    if (messages.length === 0) return { messages: [] };
     const threadId = messages[0]?.threadId;
     if (!threadId) {
       throw new error.MastraError({
@@ -2135,8 +1978,7 @@ var MemoryPG = class extends storage.MemoryStorage {
         return message;
       });
       const list = new agent.MessageList().add(messagesWithParsedContent, "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
+      return { messages: list.get.all.db() };
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -2368,13 +2210,13 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
     this.operations = operations;
     this.schema = schema;
   }
-  get aiTracingStrategy() {
+  get tracingStrategy() {
     return {
       preferred: "batch-with-updates",
       supported: ["batch-with-updates", "insert-only"]
     };
   }
-  async createAISpan(span) {
+  async createSpan(span) {
     try {
       const startedAt = span.startedAt instanceof Date ? span.startedAt.toISOString() : span.startedAt;
       const endedAt = span.endedAt instanceof Date ? span.endedAt.toISOString() : span.endedAt;
@@ -2386,11 +2228,11 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
         endedAtZ: endedAt
         // Note: createdAt/updatedAt will be set by database triggers
       };
-      return this.operations.insert({ tableName: storage.TABLE_AI_SPANS, record });
+      return this.operations.insert({ tableName: storage.TABLE_SPANS, record });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "PG_STORE_CREATE_AI_SPAN_FAILED",
+          id: "PG_STORE_CREATE_SPAN_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: {
@@ -2404,10 +2246,10 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
       );
     }
   }
-  async getAITrace(traceId) {
+  async getTrace(traceId) {
     try {
       const tableName = getTableName({
-        indexName: storage.TABLE_AI_SPANS,
+        indexName: storage.TABLE_SPANS,
         schemaName: getSchemaName(this.schema)
       });
       const spans = await this.client.manyOrNone(
@@ -2428,7 +2270,7 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
         traceId,
         spans: spans.map(
           (span) => transformFromSqlRow({
-            tableName: storage.TABLE_AI_SPANS,
+            tableName: storage.TABLE_SPANS,
             sqlRow: span
           })
         )
@@ -2436,7 +2278,7 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "PG_STORE_GET_AI_TRACE_FAILED",
+          id: "PG_STORE_GET_TRACE_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: {
@@ -2447,7 +2289,7 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
       );
     }
   }
-  async updateAISpan({
+  async updateSpan({
     spanId,
     traceId,
     updates
@@ -2461,14 +2303,14 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
         data.startedAt = data.startedAt.toISOString();
       }
       await this.operations.update({
-        tableName: storage.TABLE_AI_SPANS,
+        tableName: storage.TABLE_SPANS,
         keys: { spanId, traceId },
         data
       });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "PG_STORE_UPDATE_AI_SPAN_FAILED",
+          id: "PG_STORE_UPDATE_SPAN_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: {
@@ -2480,7 +2322,7 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
       );
     }
   }
-  async getAITracesPaginated({
+  async getTracesPaginated({
     filters,
     pagination
   }) {
@@ -2504,7 +2346,7 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
         name = `agent run: '${entityId}'`;
       } else {
         const error$1 = new error.MastraError({
-          id: "PG_STORE_GET_AI_TRACES_PAGINATED_FAILED",
+          id: "PG_STORE_GET_TRACES_PAGINATED_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: {
@@ -2524,7 +2366,7 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
       }
     }
     const tableName = getTableName({
-      indexName: storage.TABLE_AI_SPANS,
+      indexName: storage.TABLE_SPANS,
       schemaName: getSchemaName(this.schema)
     });
     try {
@@ -2564,7 +2406,7 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
         },
         spans: spans.map(
           (span) => transformFromSqlRow({
-            tableName: storage.TABLE_AI_SPANS,
+            tableName: storage.TABLE_SPANS,
             sqlRow: span
           })
         )
@@ -2572,7 +2414,7 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "PG_STORE_GET_AI_TRACES_PAGINATED_FAILED",
+          id: "PG_STORE_GET_TRACES_PAGINATED_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER
         },
@@ -2580,7 +2422,7 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
       );
     }
   }
-  async batchCreateAISpans(args) {
+  async batchCreateSpans(args) {
     try {
       const records = args.records.map((record) => {
         const startedAt = record.startedAt instanceof Date ? record.startedAt.toISOString() : record.startedAt;
@@ -2595,13 +2437,13 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
         };
       });
       return this.operations.batchInsert({
-        tableName: storage.TABLE_AI_SPANS,
+        tableName: storage.TABLE_SPANS,
         records
       });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "PG_STORE_BATCH_CREATE_AI_SPANS_FAILED",
+          id: "PG_STORE_BATCH_CREATE_SPANS_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER
         },
@@ -2609,10 +2451,10 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
       );
     }
   }
-  async batchUpdateAISpans(args) {
+  async batchUpdateSpans(args) {
     try {
       return this.operations.batchUpdate({
-        tableName: storage.TABLE_AI_SPANS,
+        tableName: storage.TABLE_SPANS,
         updates: args.records.map((record) => {
           const data = {
             ...record.updates
@@ -2636,7 +2478,7 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "PG_STORE_BATCH_UPDATE_AI_SPANS_FAILED",
+          id: "PG_STORE_BATCH_UPDATE_SPANS_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER
         },
@@ -2644,10 +2486,10 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
       );
     }
   }
-  async batchDeleteAITraces(args) {
+  async batchDeleteTraces(args) {
     try {
       const tableName = getTableName({
-        indexName: storage.TABLE_AI_SPANS,
+        indexName: storage.TABLE_SPANS,
         schemaName: getSchemaName(this.schema)
       });
       const placeholders = args.traceIds.map((_, i) => `$${i + 1}`).join(", ");
@@ -2655,7 +2497,7 @@ var ObservabilityPG = class extends storage.ObservabilityStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "PG_STORE_BATCH_DELETE_AI_TRACES_FAILED",
+          id: "PG_STORE_BATCH_DELETE_TRACES_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER
         },
@@ -2871,7 +2713,7 @@ var StoreOperationsPG = class extends storage.StoreOperations {
         schema,
         ifNotExists: timeZColumnNames
       });
-      if (tableName === storage.TABLE_AI_SPANS) {
+      if (tableName === storage.TABLE_SPANS) {
         await this.setupTimestampTriggers(tableName);
       }
     } catch (error$1) {
@@ -3257,37 +3099,31 @@ var StoreOperationsPG = class extends storage.StoreOperations {
         table: storage.TABLE_TRACES,
         columns: ["name", "startTime DESC"]
       },
-      // Composite index for evals (filter + sort)
-      {
-        name: `${schemaPrefix}mastra_evals_agent_name_created_at_idx`,
-        table: storage.TABLE_EVALS,
-        columns: ["agent_name", "created_at DESC"]
-      },
       // Composite index for scores (filter + sort)
       {
         name: `${schemaPrefix}mastra_scores_trace_id_span_id_created_at_idx`,
         table: storage.TABLE_SCORERS,
         columns: ["traceId", "spanId", "createdAt DESC"]
       },
-      // AI Spans indexes for optimal trace querying
+      // Spans indexes for optimal trace querying
       {
         name: `${schemaPrefix}mastra_ai_spans_traceid_startedat_idx`,
-        table: storage.TABLE_AI_SPANS,
+        table: storage.TABLE_SPANS,
         columns: ["traceId", "startedAt DESC"]
       },
       {
         name: `${schemaPrefix}mastra_ai_spans_parentspanid_startedat_idx`,
-        table: storage.TABLE_AI_SPANS,
+        table: storage.TABLE_SPANS,
         columns: ["parentSpanId", "startedAt DESC"]
       },
       {
         name: `${schemaPrefix}mastra_ai_spans_name_idx`,
-        table: storage.TABLE_AI_SPANS,
+        table: storage.TABLE_SPANS,
         columns: ["name"]
       },
       {
         name: `${schemaPrefix}mastra_ai_spans_spantype_startedat_idx`,
-        table: storage.TABLE_AI_SPANS,
+        table: storage.TABLE_SPANS,
         columns: ["spanType", "startedAt DESC"]
       }
     ];
@@ -3508,7 +3344,7 @@ function transformScoreRow(row) {
     metadata: storage.safelyParseJSON(row.metadata),
     output: storage.safelyParseJSON(row.output),
     additionalContext: storage.safelyParseJSON(row.additionalContext),
-    runtimeContext: storage.safelyParseJSON(row.runtimeContext),
+    requestContext: storage.safelyParseJSON(row.requestContext),
     entity: storage.safelyParseJSON(row.entity),
     createdAt: row.createdAtZ || row.createdAt,
     updatedAt: row.updatedAtZ || row.updatedAt
@@ -3546,7 +3382,7 @@ var ScoresPG = class extends storage.ScoresStorage {
       );
     }
   }
-  async getScoresByScorerId({
+  async listScoresByScorerId({
     scorerId,
     pagination,
     entityId,
@@ -3574,27 +3410,32 @@ var ScoresPG = class extends storage.ScoresStorage {
         `SELECT COUNT(*) FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: this.schema })} WHERE ${whereClause}`,
         queryParams
       );
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       if (total?.count === "0" || !total?.count) {
         return {
           pagination: {
             total: 0,
-            page: pagination.page,
-            perPage: pagination.perPage,
+            page,
+            perPage: perPageForResponse,
             hasMore: false
           },
           scores: []
         };
       }
+      const limitValue = perPageInput === false ? Number(total?.count) : perPage;
+      const end = perPageInput === false ? Number(total?.count) : start + perPage;
       const result = await this.client.manyOrNone(
         `SELECT * FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: this.schema })} WHERE ${whereClause} ORDER BY "createdAt" DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`,
-        [...queryParams, pagination.perPage, pagination.page * pagination.perPage]
+        [...queryParams, limitValue, start]
       );
       return {
         pagination: {
           total: Number(total?.count) || 0,
-          page: pagination.page,
-          perPage: pagination.perPage,
-          hasMore: Number(total?.count) > (pagination.page + 1) * pagination.perPage
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < Number(total?.count)
         },
         scores: result.map(transformScoreRow)
       };
@@ -3612,7 +3453,7 @@ var ScoresPG = class extends storage.ScoresStorage {
   async saveScore(score) {
     let parsedScore;
     try {
-      parsedScore = scores.saveScorePayloadSchema.parse(score);
+      parsedScore = evals.saveScorePayloadSchema.parse(score);
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -3620,7 +3461,7 @@ var ScoresPG = class extends storage.ScoresStorage {
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: {
-            scorer: score.scorer.name,
+            scorer: score.scorer.id,
             entityId: score.entityId,
             entityType: score.entityType,
             traceId: score.traceId || "",
@@ -3640,7 +3481,7 @@ var ScoresPG = class extends storage.ScoresStorage {
         input,
         output,
         additionalContext,
-        runtimeContext,
+        requestContext,
         entity,
         ...rest
       } = parsedScore;
@@ -3656,7 +3497,7 @@ var ScoresPG = class extends storage.ScoresStorage {
           analyzeStepResult: analyzeStepResult ? JSON.stringify(analyzeStepResult) : null,
           metadata: metadata ? JSON.stringify(metadata) : null,
           additionalContext: additionalContext ? JSON.stringify(additionalContext) : null,
-          runtimeContext: runtimeContext ? JSON.stringify(runtimeContext) : null,
+          requestContext: requestContext ? JSON.stringify(requestContext) : null,
           entity: entity ? JSON.stringify(entity) : null,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -3675,7 +3516,7 @@ var ScoresPG = class extends storage.ScoresStorage {
       );
     }
   }
-  async getScoresByRunId({
+  async listScoresByRunId({
     runId,
     pagination
   }) {
@@ -3684,27 +3525,32 @@ var ScoresPG = class extends storage.ScoresStorage {
         `SELECT COUNT(*) FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: this.schema })} WHERE "runId" = $1`,
         [runId]
       );
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       if (total?.count === "0" || !total?.count) {
         return {
           pagination: {
             total: 0,
-            page: pagination.page,
-            perPage: pagination.perPage,
+            page,
+            perPage: perPageForResponse,
             hasMore: false
           },
           scores: []
         };
       }
+      const limitValue = perPageInput === false ? Number(total?.count) : perPage;
+      const end = perPageInput === false ? Number(total?.count) : start + perPage;
       const result = await this.client.manyOrNone(
         `SELECT * FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: this.schema })} WHERE "runId" = $1 LIMIT $2 OFFSET $3`,
-        [runId, pagination.perPage, pagination.page * pagination.perPage]
+        [runId, limitValue, start]
       );
       return {
         pagination: {
           total: Number(total?.count) || 0,
-          page: pagination.page,
-          perPage: pagination.perPage,
-          hasMore: Number(total?.count) > (pagination.page + 1) * pagination.perPage
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < Number(total?.count)
         },
         scores: result.map(transformScoreRow)
       };
@@ -3719,7 +3565,7 @@ var ScoresPG = class extends storage.ScoresStorage {
       );
     }
   }
-  async getScoresByEntityId({
+  async listScoresByEntityId({
     entityId,
     entityType,
     pagination
@@ -3729,27 +3575,32 @@ var ScoresPG = class extends storage.ScoresStorage {
         `SELECT COUNT(*) FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: this.schema })} WHERE "entityId" = $1 AND "entityType" = $2`,
         [entityId, entityType]
       );
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
       if (total?.count === "0" || !total?.count) {
         return {
           pagination: {
             total: 0,
-            page: pagination.page,
-            perPage: pagination.perPage,
+            page,
+            perPage: perPageForResponse,
             hasMore: false
           },
           scores: []
         };
       }
+      const limitValue = perPageInput === false ? Number(total?.count) : perPage;
+      const end = perPageInput === false ? Number(total?.count) : start + perPage;
       const result = await this.client.manyOrNone(
         `SELECT * FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: this.schema })} WHERE "entityId" = $1 AND "entityType" = $2 LIMIT $3 OFFSET $4`,
-        [entityId, entityType, pagination.perPage, pagination.page * pagination.perPage]
+        [entityId, entityType, limitValue, start]
       );
       return {
         pagination: {
           total: Number(total?.count) || 0,
-          page: pagination.page,
-          perPage: pagination.perPage,
-          hasMore: Number(total?.count) > (pagination.page + 1) * pagination.perPage
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < Number(total?.count)
         },
         scores: result.map(transformScoreRow)
       };
@@ -3764,7 +3615,7 @@ var ScoresPG = class extends storage.ScoresStorage {
       );
     }
   }
-  async getScoresBySpan({
+  async listScoresBySpan({
     traceId,
     spanId,
     pagination
@@ -3776,18 +3627,23 @@ var ScoresPG = class extends storage.ScoresStorage {
         [traceId, spanId]
       );
       const total = Number(countSQLResult?.count ?? 0);
+      const { page, perPage: perPageInput } = pagination;
+      const perPage = storage.normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const end = perPageInput === false ? total : start + perPage;
       const result = await this.client.manyOrNone(
         `SELECT * FROM ${tableName} WHERE "traceId" = $1 AND "spanId" = $2 ORDER BY "createdAt" DESC LIMIT $3 OFFSET $4`,
-        [traceId, spanId, pagination.perPage + 1, pagination.page * pagination.perPage]
+        [traceId, spanId, limitValue, start]
       );
-      const hasMore = result.length > pagination.perPage;
-      const scores = result.slice(0, pagination.perPage).map((row) => transformScoreRow(row)) ?? [];
+      const hasMore = end < total;
+      const scores = result.map((row) => transformScoreRow(row)) ?? [];
       return {
         scores,
         pagination: {
           total,
-          page: pagination.page,
-          perPage: pagination.perPage,
+          page,
+          perPage: perPageForResponse,
           hasMore
         }
       };
@@ -3803,141 +3659,6 @@ var ScoresPG = class extends storage.ScoresStorage {
     }
   }
 };
-var TracesPG = class extends storage.TracesStorage {
-  client;
-  operations;
-  schema;
-  constructor({
-    client,
-    operations,
-    schema
-  }) {
-    super();
-    this.client = client;
-    this.operations = operations;
-    this.schema = schema;
-  }
-  async getTraces(args) {
-    if (args.fromDate || args.toDate) {
-      args.dateRange = {
-        start: args.fromDate,
-        end: args.toDate
-      };
-    }
-    try {
-      const result = await this.getTracesPaginated(args);
-      return result.traces;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_PG_STORE_GET_TRACES_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
-    }
-  }
-  async getTracesPaginated(args) {
-    const { name, scope, page = 0, perPage = 100, attributes, filters, dateRange } = args;
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-    const currentOffset = page * perPage;
-    const queryParams = [];
-    const conditions = [];
-    let paramIndex = 1;
-    if (name) {
-      conditions.push(`name LIKE $${paramIndex++}`);
-      queryParams.push(`${name}%`);
-    }
-    if (scope) {
-      conditions.push(`scope = $${paramIndex++}`);
-      queryParams.push(scope);
-    }
-    if (attributes) {
-      Object.entries(attributes).forEach(([key, value]) => {
-        const parsedKey = utils.parseFieldKey(key);
-        conditions.push(`attributes->>'${parsedKey}' = $${paramIndex++}`);
-        queryParams.push(value);
-      });
-    }
-    if (filters) {
-      Object.entries(filters).forEach(([key, value]) => {
-        const parsedKey = utils.parseFieldKey(key);
-        conditions.push(`"${parsedKey}" = $${paramIndex++}`);
-        queryParams.push(value);
-      });
-    }
-    if (fromDate) {
-      conditions.push(`"createdAt" >= $${paramIndex++}`);
-      queryParams.push(fromDate);
-    }
-    if (toDate) {
-      conditions.push(`"createdAt" <= $${paramIndex++}`);
-      queryParams.push(toDate);
-    }
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    try {
-      const countResult = await this.client.oneOrNone(
-        `SELECT COUNT(*) FROM ${getTableName({ indexName: storage.TABLE_TRACES, schemaName: getSchemaName(this.schema) })} ${whereClause}`,
-        queryParams
-      );
-      const total = Number(countResult?.count ?? 0);
-      if (total === 0) {
-        return {
-          traces: [],
-          total: 0,
-          page,
-          perPage,
-          hasMore: false
-        };
-      }
-      const dataResult = await this.client.manyOrNone(
-        `SELECT * FROM ${getTableName({ indexName: storage.TABLE_TRACES, schemaName: getSchemaName(this.schema) })} ${whereClause} ORDER BY "startTime" DESC LIMIT $${paramIndex++} OFFSET $${paramIndex++}`,
-        [...queryParams, perPage, currentOffset]
-      );
-      const traces = dataResult.map((row) => ({
-        id: row.id,
-        parentSpanId: row.parentSpanId,
-        traceId: row.traceId,
-        name: row.name,
-        scope: row.scope,
-        kind: row.kind,
-        status: storage.safelyParseJSON(row.status),
-        events: storage.safelyParseJSON(row.events),
-        links: storage.safelyParseJSON(row.links),
-        attributes: storage.safelyParseJSON(row.attributes),
-        startTime: row.startTime,
-        endTime: row.endTime,
-        other: storage.safelyParseJSON(row.other),
-        createdAt: row.createdAtZ || row.createdAt
-      }));
-      return {
-        traces,
-        total,
-        page,
-        perPage,
-        hasMore: currentOffset + traces.length < total
-      };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_PG_STORE_GET_TRACES_PAGINATED_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
-    }
-  }
-  async batchTraceInsert({ records }) {
-    this.logger.debug("Batch inserting traces", { count: records.length });
-    await this.operations.batchInsert({
-      tableName: storage.TABLE_TRACES,
-      records
-    });
-  }
-};
 function parseWorkflowRun(row) {
   let parsedSnapshot = row.snapshot;
   if (typeof parsedSnapshot === "string") {
@@ -3975,7 +3696,7 @@ var WorkflowsPG = class extends storage.WorkflowsStorage {
     // runId,
     // stepId,
     // result,
-    // runtimeContext,
+    // requestContext,
   }) {
     throw new Error("Method not implemented.");
   }
@@ -4078,12 +3799,12 @@ var WorkflowsPG = class extends storage.WorkflowsStorage {
       );
     }
   }
-  async getWorkflowRuns({
+  async listWorkflowRuns({
     workflowName,
     fromDate,
     toDate,
-    limit,
-    offset,
+    perPage,
+    page,
     resourceId
   } = {}) {
     try {
@@ -4117,20 +3838,23 @@ var WorkflowsPG = class extends storage.WorkflowsStorage {
       }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
       let total = 0;
-      if (limit !== void 0 && offset !== void 0) {
+      const usePagination = typeof perPage === "number" && typeof page === "number";
+      if (usePagination) {
         const countResult = await this.client.one(
           `SELECT COUNT(*) as count FROM ${getTableName({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: this.schema })} ${whereClause}`,
           values
         );
         total = Number(countResult.count);
       }
+      const normalizedPerPage = usePagination ? storage.normalizePerPage(perPage, Number.MAX_SAFE_INTEGER) : 0;
+      const offset = usePagination ? page * normalizedPerPage : void 0;
       const query = `
           SELECT * FROM ${getTableName({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: this.schema })}
           ${whereClause}
           ORDER BY "createdAt" DESC
-          ${limit !== void 0 && offset !== void 0 ? ` LIMIT $${paramIndex} OFFSET $${paramIndex + 1}` : ""}
+          ${usePagination ? ` LIMIT $${paramIndex} OFFSET $${paramIndex + 1}` : ""}
         `;
-      const queryValues = limit !== void 0 && offset !== void 0 ? [...values, limit, offset] : values;
+      const queryValues = usePagination ? [...values, normalizedPerPage, offset] : values;
       const result = await this.client.manyOrNone(query, queryValues);
       const runs = (result || []).map((row) => {
         return parseWorkflowRun(row);
@@ -4139,7 +3863,7 @@ var WorkflowsPG = class extends storage.WorkflowsStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_PG_STORE_GET_WORKFLOW_RUNS_FAILED",
+          id: "MASTRA_STORAGE_PG_STORE_LIST_WORKFLOW_RUNS_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
@@ -4163,10 +3887,11 @@ var PostgresStore = class extends storage.MastraStorage {
   constructor(config) {
     try {
       validateConfig("PostgresStore", config);
-      super({ name: "PostgresStore" });
+      super({ id: config.id, name: "PostgresStore" });
       this.schema = config.schemaName || "public";
       if (isConnectionStringConfig(config)) {
         this.#config = {
+          id: config.id,
           connectionString: config.connectionString,
           max: config.max,
           idleTimeoutMillis: config.idleTimeoutMillis,
@@ -4175,11 +3900,13 @@ var PostgresStore = class extends storage.MastraStorage {
       } else if (isCloudSqlConfig(config)) {
         this.#config = {
           ...config,
+          id: config.id,
           max: config.max,
           idleTimeoutMillis: config.idleTimeoutMillis
         };
       } else if (isHostConfig(config)) {
         this.#config = {
+          id: config.id,
           host: config.host,
           port: config.port,
           database: config.database,
@@ -4216,17 +3943,13 @@ var PostgresStore = class extends storage.MastraStorage {
       this.#db = this.#pgp(this.#config);
       const operations = new StoreOperationsPG({ client: this.#db, schemaName: this.schema });
       const scores = new ScoresPG({ client: this.#db, operations, schema: this.schema });
-      const traces = new TracesPG({ client: this.#db, operations, schema: this.schema });
       const workflows = new WorkflowsPG({ client: this.#db, operations, schema: this.schema });
-      const legacyEvals = new LegacyEvalsPG({ client: this.#db, schema: this.schema });
       const memory = new MemoryPG({ client: this.#db, schema: this.schema, operations });
       const observability = new ObservabilityPG({ client: this.#db, operations, schema: this.schema });
       this.stores = {
         operations,
         scores,
-        traces,
         workflows,
-        legacyEvals,
         memory,
         observability
       };
@@ -4267,30 +3990,11 @@ var PostgresStore = class extends storage.MastraStorage {
       hasColumn: true,
       createTable: true,
       deleteMessages: true,
-      aiTracing: true,
+      observabilityInstance: true,
       indexManagement: true,
-      getScoresBySpan: true
+      listScoresBySpan: true
     };
   }
-  /** @deprecated use getEvals instead */
-  async getEvalsByAgentName(agentName, type) {
-    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
-  }
-  async getEvals(options = {}) {
-    return this.stores.legacyEvals.getEvals(options);
-  }
-  /**
-   * @deprecated use getTracesPaginated instead
-   */
-  async getTraces(args) {
-    return this.stores.traces.getTraces(args);
-  }
-  async getTracesPaginated(args) {
-    return this.stores.traces.getTracesPaginated(args);
-  }
-  async batchTraceInsert({ records }) {
-    return this.stores.traces.batchTraceInsert({ records });
-  }
   async createTable({
     tableName,
     schema
@@ -4325,15 +4029,6 @@ var PostgresStore = class extends storage.MastraStorage {
   async getThreadById({ threadId }) {
     return this.stores.memory.getThreadById({ threadId });
   }
-  /**
-   * @deprecated use getThreadsByResourceIdPaginated instead
-   */
-  async getThreadsByResourceId(args) {
-    return this.stores.memory.getThreadsByResourceId(args);
-  }
-  async getThreadsByResourceIdPaginated(args) {
-    return this.stores.memory.getThreadsByResourceIdPaginated(args);
-  }
   async saveThread({ thread }) {
     return this.stores.memory.saveThread({ thread });
   }
@@ -4347,17 +4042,8 @@ var PostgresStore = class extends storage.MastraStorage {
   async deleteThread({ threadId }) {
     return this.stores.memory.deleteThread({ threadId });
   }
-  async getMessages(args) {
-    return this.stores.memory.getMessages(args);
-  }
-  async getMessagesById({
-    messageIds,
-    format
-  }) {
-    return this.stores.memory.getMessagesById({ messageIds, format });
-  }
-  async getMessagesPaginated(args) {
-    return this.stores.memory.getMessagesPaginated(args);
+  async listMessagesById({ messageIds }) {
+    return this.stores.memory.listMessagesById({ messageIds });
   }
   async saveMessages(args) {
     return this.stores.memory.saveMessages(args);
@@ -4391,9 +4077,9 @@ var PostgresStore = class extends storage.MastraStorage {
     runId,
     stepId,
     result,
-    runtimeContext
+    requestContext
   }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, runtimeContext });
+    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
   }
   async updateWorkflowState({
     workflowName,
@@ -4416,15 +4102,15 @@ var PostgresStore = class extends storage.MastraStorage {
   }) {
     return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
   }
-  async getWorkflowRuns({
+  async listWorkflowRuns({
     workflowName,
     fromDate,
     toDate,
-    limit,
-    offset,
+    perPage,
+    page,
     resourceId
   } = {}) {
-    return this.stores.workflows.getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId });
+    return this.stores.workflows.listWorkflowRuns({ workflowName, fromDate, toDate, perPage, page, resourceId });
   }
   async getWorkflowRunById({
     runId,
@@ -4436,9 +4122,9 @@ var PostgresStore = class extends storage.MastraStorage {
     this.pgp.end();
   }
   /**
-   * AI Tracing / Observability
+   * Tracing / Observability
    */
-  async createAISpan(span) {
+  async createSpan(span) {
     if (!this.stores.observability) {
       throw new error.MastraError({
         id: "PG_STORE_OBSERVABILITY_NOT_INITIALIZED",
@@ -4447,9 +4133,9 @@ var PostgresStore = class extends storage.MastraStorage {
         text: "Observability storage is not initialized"
       });
     }
-    return this.stores.observability.createAISpan(span);
+    return this.stores.observability.createSpan(span);
   }
-  async updateAISpan({
+  async updateSpan({
     spanId,
     traceId,
     updates
@@ -4462,9 +4148,9 @@ var PostgresStore = class extends storage.MastraStorage {
         text: "Observability storage is not initialized"
       });
     }
-    return this.stores.observability.updateAISpan({ spanId, traceId, updates });
+    return this.stores.observability.updateSpan({ spanId, traceId, updates });
   }
-  async getAITrace(traceId) {
+  async getTrace(traceId) {
     if (!this.stores.observability) {
       throw new error.MastraError({
         id: "PG_STORE_OBSERVABILITY_NOT_INITIALIZED",
@@ -4473,9 +4159,9 @@ var PostgresStore = class extends storage.MastraStorage {
         text: "Observability storage is not initialized"
       });
     }
-    return this.stores.observability.getAITrace(traceId);
+    return this.stores.observability.getTrace(traceId);
   }
-  async getAITracesPaginated(args) {
+  async getTracesPaginated(args) {
     if (!this.stores.observability) {
       throw new error.MastraError({
         id: "PG_STORE_OBSERVABILITY_NOT_INITIALIZED",
@@ -4484,9 +4170,9 @@ var PostgresStore = class extends storage.MastraStorage {
         text: "Observability storage is not initialized"
       });
     }
-    return this.stores.observability.getAITracesPaginated(args);
+    return this.stores.observability.getTracesPaginated(args);
   }
-  async batchCreateAISpans(args) {
+  async batchCreateSpans(args) {
     if (!this.stores.observability) {
       throw new error.MastraError({
         id: "PG_STORE_OBSERVABILITY_NOT_INITIALIZED",
@@ -4495,9 +4181,9 @@ var PostgresStore = class extends storage.MastraStorage {
         text: "Observability storage is not initialized"
       });
     }
-    return this.stores.observability.batchCreateAISpans(args);
+    return this.stores.observability.batchCreateSpans(args);
   }
-  async batchUpdateAISpans(args) {
+  async batchUpdateSpans(args) {
     if (!this.stores.observability) {
       throw new error.MastraError({
         id: "PG_STORE_OBSERVABILITY_NOT_INITIALIZED",
@@ -4506,9 +4192,9 @@ var PostgresStore = class extends storage.MastraStorage {
         text: "Observability storage is not initialized"
       });
     }
-    return this.stores.observability.batchUpdateAISpans(args);
+    return this.stores.observability.batchUpdateSpans(args);
   }
-  async batchDeleteAITraces(args) {
+  async batchDeleteTraces(args) {
     if (!this.stores.observability) {
       throw new error.MastraError({
         id: "PG_STORE_OBSERVABILITY_NOT_INITIALIZED",
@@ -4517,7 +4203,7 @@ var PostgresStore = class extends storage.MastraStorage {
         text: "Observability storage is not initialized"
       });
     }
-    return this.stores.observability.batchDeleteAITraces(args);
+    return this.stores.observability.batchDeleteTraces(args);
   }
   /**
    * Scorers
@@ -4525,41 +4211,41 @@ var PostgresStore = class extends storage.MastraStorage {
   async getScoreById({ id }) {
     return this.stores.scores.getScoreById({ id });
   }
-  async getScoresByScorerId({
+  async listScoresByScorerId({
     scorerId,
     pagination,
     entityId,
     entityType,
     source
   }) {
-    return this.stores.scores.getScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
+    return this.stores.scores.listScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
   }
   async saveScore(score) {
     return this.stores.scores.saveScore(score);
   }
-  async getScoresByRunId({
+  async listScoresByRunId({
     runId,
     pagination
   }) {
-    return this.stores.scores.getScoresByRunId({ runId, pagination });
+    return this.stores.scores.listScoresByRunId({ runId, pagination });
   }
-  async getScoresByEntityId({
+  async listScoresByEntityId({
     entityId,
     entityType,
     pagination
   }) {
-    return this.stores.scores.getScoresByEntityId({
+    return this.stores.scores.listScoresByEntityId({
       entityId,
       entityType,
       pagination
     });
   }
-  async getScoresBySpan({
+  async listScoresBySpan({
     traceId,
     spanId,
     pagination
   }) {
-    return this.stores.scores.getScoresBySpan({ traceId, spanId, pagination });
+    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
   }
 };