@mastra/pg 0.12.4 → 0.12.6-alpha.0

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pg@0.12.4-alpha.0 build /home/runner/work/mastra/mastra/stores/pg
+> @mastra/pg@0.12.6-alpha.0 build /home/runner/work/mastra/mastra/stores/pg
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.0
 TSC Build start
-TSC ⚡️ Build success in 16748ms
+TSC ⚡️ Build success in 17910ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/pg/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/pg/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 14394ms
+DTS ⚡️ Build success in 13382ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 102.98 KB
-ESM ⚡️ Build success in 2355ms
-CJS dist/index.cjs 104.50 KB
-CJS ⚡️ Build success in 2355ms
+ESM dist/index.js 104.78 KB
+ESM ⚡️ Build success in 2545ms
+CJS dist/index.cjs 106.34 KB
+CJS ⚡️ Build success in 2546ms

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # @mastra/pg
 
+## 0.12.6-alpha.0
+
+### Patch Changes
+
+- ff9c125: enhance thread retrieval with sorting options in libsql and pg
+- b8efbb9: feat: add flexible deleteMessages method to memory API
+  - Added `memory.deleteMessages(input)` method that accepts multiple input types:
+    - Single message ID as string: `deleteMessages('msg-123')`
+    - Array of message IDs: `deleteMessages(['msg-1', 'msg-2'])`
+    - Message object with id property: `deleteMessages({ id: 'msg-123' })`
+    - Array of message objects: `deleteMessages([{ id: 'msg-1' }, { id: 'msg-2' }])`
+  - Implemented in all storage adapters (LibSQL, PostgreSQL, Upstash, InMemory)
+  - Added REST API endpoint: `POST /api/memory/messages/delete`
+  - Updated client SDK: `thread.deleteMessages()` accepts all input types
+  - Updates thread timestamps when messages are deleted
+  - Added comprehensive test coverage and documentation
+
+- Updated dependencies [27cc97a]
+- Updated dependencies [41daa63]
+- Updated dependencies [254a36b]
+- Updated dependencies [0b89602]
+- Updated dependencies [4d37822]
+- Updated dependencies [ff9c125]
+- Updated dependencies [b8efbb9]
+- Updated dependencies [71466e7]
+- Updated dependencies [0c99fbe]
+  - @mastra/core@0.12.0-alpha.2
+
+## 0.12.5
+
+### Patch Changes
+
+- ce088f5: Update all peerdeps to latest core
+  - @mastra/core@0.11.1
+
 ## 0.12.4
 
 ### Patch Changes

package/dist/_tsup-dts-rollup.d.cts

@@ -39,6 +39,7 @@ import type { StorageResourceType } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
 import { StoreOperations } from '@mastra/core/storage';
 import type { TABLE_NAMES } from '@mastra/core/storage';
+import type { ThreadSortOptions } from '@mastra/core/storage';
 import type { Trace } from '@mastra/core/telemetry';
 import { TracesStorage } from '@mastra/core/storage';
 import type { UpdateVectorParams } from '@mastra/core/vector';
@@ -194,12 +195,12 @@ export declare class MemoryPG extends MemoryStorage {
      */
     getThreadsByResourceId(args: {
         resourceId: string;
-    }): Promise<StorageThreadType[]>;
+    } & ThreadSortOptions): Promise<StorageThreadType[]>;
     getThreadsByResourceIdPaginated(args: {
         resourceId: string;
         page: number;
         perPage: number;
-    }): Promise<PaginationInfo & {
+    } & ThreadSortOptions): Promise<PaginationInfo & {
         threads: StorageThreadType[];
     }>;
     saveThread({ thread }: {
@@ -245,6 +246,7 @@ export declare class MemoryPG extends MemoryStorage {
             };
         })[];
     }): Promise<MastraMessageV2_2[]>;
+    deleteMessages(messageIds: string[]): Promise<void>;
     getResourceById({ resourceId }: {
         resourceId: string;
     }): Promise<StorageResourceType | null>;
@@ -429,6 +431,7 @@ declare class PostgresStore extends MastraStorage {
         resourceWorkingMemory: boolean;
         hasColumn: boolean;
         createTable: boolean;
+        deleteMessages: boolean;
     };
     /** @deprecated use getEvals instead */
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
@@ -486,12 +489,12 @@ declare class PostgresStore extends MastraStorage {
      */
     getThreadsByResourceId(args: {
         resourceId: string;
-    }): Promise<StorageThreadType[]>;
+    } & ThreadSortOptions): Promise<StorageThreadType[]>;
     getThreadsByResourceIdPaginated(args: {
         resourceId: string;
         page: number;
         perPage: number;
-    }): Promise<PaginationInfo & {
+    } & ThreadSortOptions): Promise<PaginationInfo & {
         threads: StorageThreadType[];
     }>;
     saveThread({ thread }: {
@@ -536,6 +539,7 @@ declare class PostgresStore extends MastraStorage {
             };
         })[];
     }): Promise<MastraMessageV2[]>;
+    deleteMessages(messageIds: string[]): Promise<void>;
     getResourceById({ resourceId }: {
         resourceId: string;
     }): Promise<StorageResourceType | null>;

package/dist/_tsup-dts-rollup.d.ts

@@ -39,6 +39,7 @@ import type { StorageResourceType } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
 import { StoreOperations } from '@mastra/core/storage';
 import type { TABLE_NAMES } from '@mastra/core/storage';
+import type { ThreadSortOptions } from '@mastra/core/storage';
 import type { Trace } from '@mastra/core/telemetry';
 import { TracesStorage } from '@mastra/core/storage';
 import type { UpdateVectorParams } from '@mastra/core/vector';
@@ -194,12 +195,12 @@ export declare class MemoryPG extends MemoryStorage {
      */
     getThreadsByResourceId(args: {
         resourceId: string;
-    }): Promise<StorageThreadType[]>;
+    } & ThreadSortOptions): Promise<StorageThreadType[]>;
     getThreadsByResourceIdPaginated(args: {
         resourceId: string;
         page: number;
         perPage: number;
-    }): Promise<PaginationInfo & {
+    } & ThreadSortOptions): Promise<PaginationInfo & {
         threads: StorageThreadType[];
     }>;
     saveThread({ thread }: {
@@ -245,6 +246,7 @@ export declare class MemoryPG extends MemoryStorage {
             };
         })[];
     }): Promise<MastraMessageV2_2[]>;
+    deleteMessages(messageIds: string[]): Promise<void>;
     getResourceById({ resourceId }: {
         resourceId: string;
     }): Promise<StorageResourceType | null>;
@@ -429,6 +431,7 @@ declare class PostgresStore extends MastraStorage {
         resourceWorkingMemory: boolean;
         hasColumn: boolean;
         createTable: boolean;
+        deleteMessages: boolean;
     };
     /** @deprecated use getEvals instead */
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
@@ -486,12 +489,12 @@ declare class PostgresStore extends MastraStorage {
      */
     getThreadsByResourceId(args: {
         resourceId: string;
-    }): Promise<StorageThreadType[]>;
+    } & ThreadSortOptions): Promise<StorageThreadType[]>;
     getThreadsByResourceIdPaginated(args: {
         resourceId: string;
         page: number;
         perPage: number;
-    }): Promise<PaginationInfo & {
+    } & ThreadSortOptions): Promise<PaginationInfo & {
         threads: StorageThreadType[];
     }>;
     saveThread({ thread }: {
@@ -536,6 +539,7 @@ declare class PostgresStore extends MastraStorage {
             };
         })[];
     }): Promise<MastraMessageV2[]>;
+    deleteMessages(messageIds: string[]): Promise<void>;
     getResourceById({ resourceId }: {
         resourceId: string;
     }): Promise<StorageResourceType | null>;

package/dist/index.cjs

@@ -1284,12 +1284,14 @@ var MemoryPG = class extends storage.MemoryStorage {
    * @deprecated use getThreadsByResourceIdPaginated instead
    */
   async getThreadsByResourceId(args) {
-    const { resourceId } = 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 "createdAt" DESC`;
+      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,
@@ -1304,6 +1306,8 @@ var MemoryPG = class extends storage.MemoryStorage {
   }
   async getThreadsByResourceIdPaginated(args) {
     const { resourceId, page = 0, perPage: perPageInput } = args;
+    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`;
@@ -1322,7 +1326,7 @@ var MemoryPG = class extends storage.MemoryStorage {
           hasMore: false
         };
       }
-      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "createdAt" DESC LIMIT $2 OFFSET $3`;
+      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 threads = (rows || []).map((thread) => ({
         ...thread,
@@ -1882,6 +1886,40 @@ var MemoryPG = class extends storage.MemoryStorage {
       return message;
     });
   }
+  async deleteMessages(messageIds) {
+    if (!messageIds || messageIds.length === 0) {
+      return;
+    }
+    try {
+      const messageTableName = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
+      const threadTableName = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
+      await this.client.tx(async (t) => {
+        const placeholders = messageIds.map((_, idx) => `$${idx + 1}`).join(",");
+        const messages = await t.manyOrNone(
+          `SELECT DISTINCT thread_id FROM ${messageTableName} WHERE id IN (${placeholders})`,
+          messageIds
+        );
+        const threadIds = messages?.map((msg) => msg.thread_id).filter(Boolean) || [];
+        await t.none(`DELETE FROM ${messageTableName} WHERE id IN (${placeholders})`, messageIds);
+        if (threadIds.length > 0) {
+          const updatePromises = threadIds.map(
+            (threadId) => t.none(`UPDATE ${threadTableName} SET "updatedAt" = NOW(), "updatedAtZ" = NOW() WHERE id = $1`, [threadId])
+          );
+          await Promise.all(updatePromises);
+        }
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "PG_STORE_DELETE_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { messageIds: messageIds.join(", ") }
+        },
+        error$1
+      );
+    }
+  }
   async getResourceById({ resourceId }) {
     const tableName = getTableName({ indexName: storage.TABLE_RESOURCES, schemaName: getSchemaName(this.schema) });
     const result = await this.client.oneOrNone(
@@ -2858,7 +2896,8 @@ var PostgresStore = class extends storage.MastraStorage {
       selectByIncludeResourceScope: true,
       resourceWorkingMemory: true,
       hasColumn: true,
-      createTable: true
+      createTable: true,
+      deleteMessages: true
     };
   }
   /** @deprecated use getEvals instead */
@@ -2950,6 +2989,9 @@ var PostgresStore = class extends storage.MastraStorage {
   }) {
     return this.stores.memory.updateMessages({ messages });
   }
+  async deleteMessages(messageIds) {
+    return this.stores.memory.deleteMessages(messageIds);
+  }
   async getResourceById({ resourceId }) {
     return this.stores.memory.getResourceById({ resourceId });
   }

package/dist/index.js

@@ -1276,12 +1276,14 @@ var MemoryPG = class extends MemoryStorage {
    * @deprecated use getThreadsByResourceIdPaginated instead
    */
   async getThreadsByResourceId(args) {
-    const { resourceId } = args;
+    const resourceId = args.resourceId;
+    const orderBy = this.castThreadOrderBy(args.orderBy);
+    const sortDirection = this.castThreadSortDirection(args.sortDirection);
     try {
       const tableName = getTableName({ indexName: 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 "createdAt" DESC`;
+      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,
@@ -1296,6 +1298,8 @@ var MemoryPG = class extends MemoryStorage {
   }
   async getThreadsByResourceIdPaginated(args) {
     const { resourceId, page = 0, perPage: perPageInput } = args;
+    const orderBy = this.castThreadOrderBy(args.orderBy);
+    const sortDirection = this.castThreadSortDirection(args.sortDirection);
     try {
       const tableName = getTableName({ indexName: TABLE_THREADS, schemaName: getSchemaName(this.schema) });
       const baseQuery = `FROM ${tableName} WHERE "resourceId" = $1`;
@@ -1314,7 +1318,7 @@ var MemoryPG = class extends MemoryStorage {
           hasMore: false
         };
       }
-      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "createdAt" DESC LIMIT $2 OFFSET $3`;
+      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 threads = (rows || []).map((thread) => ({
         ...thread,
@@ -1874,6 +1878,40 @@ var MemoryPG = class extends MemoryStorage {
       return message;
     });
   }
+  async deleteMessages(messageIds) {
+    if (!messageIds || messageIds.length === 0) {
+      return;
+    }
+    try {
+      const messageTableName = getTableName({ indexName: TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
+      const threadTableName = getTableName({ indexName: TABLE_THREADS, schemaName: getSchemaName(this.schema) });
+      await this.client.tx(async (t) => {
+        const placeholders = messageIds.map((_, idx) => `$${idx + 1}`).join(",");
+        const messages = await t.manyOrNone(
+          `SELECT DISTINCT thread_id FROM ${messageTableName} WHERE id IN (${placeholders})`,
+          messageIds
+        );
+        const threadIds = messages?.map((msg) => msg.thread_id).filter(Boolean) || [];
+        await t.none(`DELETE FROM ${messageTableName} WHERE id IN (${placeholders})`, messageIds);
+        if (threadIds.length > 0) {
+          const updatePromises = threadIds.map(
+            (threadId) => t.none(`UPDATE ${threadTableName} SET "updatedAt" = NOW(), "updatedAtZ" = NOW() WHERE id = $1`, [threadId])
+          );
+          await Promise.all(updatePromises);
+        }
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "PG_STORE_DELETE_MESSAGES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { messageIds: messageIds.join(", ") }
+        },
+        error
+      );
+    }
+  }
   async getResourceById({ resourceId }) {
     const tableName = getTableName({ indexName: TABLE_RESOURCES, schemaName: getSchemaName(this.schema) });
     const result = await this.client.oneOrNone(
@@ -2850,7 +2888,8 @@ var PostgresStore = class extends MastraStorage {
       selectByIncludeResourceScope: true,
       resourceWorkingMemory: true,
       hasColumn: true,
-      createTable: true
+      createTable: true,
+      deleteMessages: true
     };
   }
   /** @deprecated use getEvals instead */
@@ -2942,6 +2981,9 @@ var PostgresStore = class extends MastraStorage {
   }) {
     return this.stores.memory.updateMessages({ messages });
   }
+  async deleteMessages(messageIds) {
+    return this.stores.memory.deleteMessages(messageIds);
+  }
   async getResourceById({ resourceId }) {
     return this.stores.memory.getResourceById({ resourceId });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pg",
-  "version": "0.12.4",
+  "version": "0.12.6-alpha.0",
   "description": "Postgres provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -33,12 +33,12 @@
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
-    "@internal/lint": "0.0.21",
-    "@internal/storage-test-utils": "0.0.17",
-    "@mastra/core": "0.11.0"
+    "@internal/lint": "0.0.23",
+    "@internal/storage-test-utils": "0.0.19",
+    "@mastra/core": "0.12.0-alpha.2"
   },
   "peerDependencies": {
-    "@mastra/core": ">=0.10.7-0 <0.11.0-0"
+    "@mastra/core": ">=0.10.7-0 <0.12.0-0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/storage/domains/memory/index.ts

@@ -9,7 +9,12 @@ import {
   TABLE_RESOURCES,
   TABLE_THREADS,
 } from '@mastra/core/storage';
-import type { StorageGetMessagesArg, PaginationInfo, StorageResourceType } from '@mastra/core/storage';
+import type {
+  StorageGetMessagesArg,
+  PaginationInfo,
+  StorageResourceType,
+  ThreadSortOptions,
+} from '@mastra/core/storage';
 import type { IDatabase } from 'pg-promise';
 import type { StoreOperationsPG } from '../operations';
 import { getTableName, getSchemaName } from '../utils';
@@ -73,15 +78,17 @@ export class MemoryPG extends MemoryStorage {
   /**
    * @deprecated use getThreadsByResourceIdPaginated instead
    */
-  public async getThreadsByResourceId(args: { resourceId: string }): Promise<StorageThreadType[]> {
-    const { resourceId } = args;
+  public async getThreadsByResourceId(args: { resourceId: string } & ThreadSortOptions): Promise<StorageThreadType[]> {
+    const resourceId = args.resourceId;
+    const orderBy = this.castThreadOrderBy(args.orderBy);
+    const sortDirection = this.castThreadSortDirection(args.sortDirection);
 
     try {
       const tableName = getTableName({ indexName: TABLE_THREADS, schemaName: getSchemaName(this.schema) });
       const baseQuery = `FROM ${tableName} WHERE "resourceId" = $1`;
       const queryParams: any[] = [resourceId];
 
-      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "createdAt" DESC`;
+      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,
@@ -95,12 +102,16 @@ export class MemoryPG extends MemoryStorage {
     }
   }
 
-  public async getThreadsByResourceIdPaginated(args: {
-    resourceId: string;
-    page: number;
-    perPage: number;
-  }): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
+  public async getThreadsByResourceIdPaginated(
+    args: {
+      resourceId: string;
+      page: number;
+      perPage: number;
+    } & ThreadSortOptions,
+  ): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
     const { resourceId, page = 0, perPage: perPageInput } = args;
+    const orderBy = this.castThreadOrderBy(args.orderBy);
+    const sortDirection = this.castThreadSortDirection(args.sortDirection);
     try {
       const tableName = getTableName({ indexName: TABLE_THREADS, schemaName: getSchemaName(this.schema) });
       const baseQuery = `FROM ${tableName} WHERE "resourceId" = $1`;
@@ -122,7 +133,7 @@ export class MemoryPG extends MemoryStorage {
         };
       }
 
-      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "createdAt" DESC LIMIT $2 OFFSET $3`;
+      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 threads = (rows || []).map(thread => ({
@@ -801,6 +812,51 @@ export class MemoryPG extends MemoryStorage {
     });
   }
 
+  async deleteMessages(messageIds: string[]): Promise<void> {
+    if (!messageIds || messageIds.length === 0) {
+      return;
+    }
+
+    try {
+      const messageTableName = getTableName({ indexName: TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
+      const threadTableName = getTableName({ indexName: TABLE_THREADS, schemaName: getSchemaName(this.schema) });
+
+      await this.client.tx(async t => {
+        // Get thread IDs for all messages
+        const placeholders = messageIds.map((_, idx) => `$${idx + 1}`).join(',');
+        const messages = await t.manyOrNone(
+          `SELECT DISTINCT thread_id FROM ${messageTableName} WHERE id IN (${placeholders})`,
+          messageIds,
+        );
+
+        const threadIds = messages?.map(msg => msg.thread_id).filter(Boolean) || [];
+
+        // Delete all messages
+        await t.none(`DELETE FROM ${messageTableName} WHERE id IN (${placeholders})`, messageIds);
+
+        // Update thread timestamps
+        if (threadIds.length > 0) {
+          const updatePromises = threadIds.map(threadId =>
+            t.none(`UPDATE ${threadTableName} SET "updatedAt" = NOW(), "updatedAtZ" = NOW() WHERE id = $1`, [threadId]),
+          );
+          await Promise.all(updatePromises);
+        }
+      });
+
+      // TODO: Delete from vector store if semantic recall is enabled
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'PG_STORE_DELETE_MESSAGES_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { messageIds: messageIds.join(', ') },
+        },
+        error,
+      );
+    }
+  }
+
   async getResourceById({ resourceId }: { resourceId: string }): Promise<StorageResourceType | null> {
     const tableName = getTableName({ indexName: TABLE_RESOURCES, schemaName: getSchemaName(this.schema) });
     const result = await this.client.oneOrNone<StorageResourceType & { createdAtZ: Date; updatedAtZ: Date }>(

package/src/storage/index.ts

@@ -17,6 +17,7 @@ import type {
   PaginationArgs,
   StoragePagination,
   StorageDomains,
+  ThreadSortOptions,
 } from '@mastra/core/storage';
 import type { Trace } from '@mastra/core/telemetry';
 import type { WorkflowRunState } from '@mastra/core/workflows';
@@ -127,6 +128,7 @@ export class PostgresStore extends MastraStorage {
       resourceWorkingMemory: true,
       hasColumn: true,
       createTable: true,
+      deleteMessages: true,
     };
   }
 
@@ -212,15 +214,17 @@ export class PostgresStore extends MastraStorage {
   /**
    * @deprecated use getThreadsByResourceIdPaginated instead
    */
-  public async getThreadsByResourceId(args: { resourceId: string }): Promise<StorageThreadType[]> {
+  public async getThreadsByResourceId(args: { resourceId: string } & ThreadSortOptions): Promise<StorageThreadType[]> {
     return this.stores.memory.getThreadsByResourceId(args);
   }
 
-  public async getThreadsByResourceIdPaginated(args: {
-    resourceId: string;
-    page: number;
-    perPage: number;
-  }): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
+  public async getThreadsByResourceIdPaginated(
+    args: {
+      resourceId: string;
+      page: number;
+      perPage: number;
+    } & ThreadSortOptions,
+  ): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
     return this.stores.memory.getThreadsByResourceIdPaginated(args);
   }
 
@@ -287,6 +291,10 @@ export class PostgresStore extends MastraStorage {
     return this.stores.memory.updateMessages({ messages });
   }
 
+  async deleteMessages(messageIds: string[]): Promise<void> {
+    return this.stores.memory.deleteMessages(messageIds);
+  }
+
   async getResourceById({ resourceId }: { resourceId: string }): Promise<StorageResourceType | null> {
     return this.stores.memory.getResourceById({ resourceId });
   }