@mastra/pg 0.10.2-alpha.1 → 0.10.2-alpha.2

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pg@0.10.2-alpha.1 build /home/runner/work/mastra/mastra/stores/pg
+> @mastra/pg@0.10.2-alpha.2 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 10884ms
+TSC ⚡️ Build success in 10152ms
 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 12247ms
+DTS ⚡️ Build success in 12410ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 66.09 KB
-ESM ⚡️ Build success in 1701ms
-CJS dist/index.cjs 66.65 KB
-CJS ⚡️ Build success in 1701ms
+ESM dist/index.js 67.23 KB
+ESM ⚡️ Build success in 1748ms
+CJS dist/index.cjs 67.79 KB
+CJS ⚡️ Build success in 1748ms

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @mastra/pg
 
+## 0.10.2-alpha.2
+
+### Patch Changes
+
+- 48eddb9: update filter logic in Memory class to support semantic recall search scope
+- Updated dependencies [48eddb9]
+  - @mastra/core@0.10.4-alpha.2
+
 ## 0.10.2-alpha.1
 
 ### Patch Changes

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

@@ -272,6 +272,9 @@ declare class PostgresStore extends MastraStorage {
     private setupSchemaPromise;
     private schemaSetupComplete;
     constructor(config: PostgresConfig);
+    get supports(): {
+        selectByIncludeResourceScope: boolean;
+    };
     private getTableName;
     /** @deprecated use getEvals instead */
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;

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

@@ -272,6 +272,9 @@ declare class PostgresStore extends MastraStorage {
     private setupSchemaPromise;
     private schemaSetupComplete;
     constructor(config: PostgresConfig);
+    get supports(): {
+        selectByIncludeResourceScope: boolean;
+    };
     private getTableName;
     /** @deprecated use getEvals instead */
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;

package/dist/index.cjs

@@ -944,6 +944,11 @@ var PostgresStore = class extends storage.MastraStorage {
       }
     );
   }
+  get supports() {
+    return {
+      selectByIncludeResourceScope: true
+    };
+  }
   getTableName(indexName) {
     const parsedIndexName = utils.parseSqlIdentifier(indexName, "table name");
     const parsedSchemaName = this.schema ? utils.parseSqlIdentifier(this.schema, "schema name") : void 0;
@@ -1434,47 +1439,62 @@ var PostgresStore = class extends storage.MastraStorage {
       let rows = [];
       const include = selectBy?.include || [];
       if (include.length) {
-        rows = await this.db.manyOrNone(
-          `
-            WITH ordered_messages AS (
-              SELECT 
-                *,
-                ROW_NUMBER() OVER (${orderByStatement}) as row_num
-              FROM ${this.getTableName(storage.TABLE_MESSAGES)}
-              WHERE thread_id = $1
-            )
-            SELECT
-              m.id, 
-              m.content, 
-              m.role, 
-              m.type,
-              m."createdAt", 
-              m.thread_id AS "threadId"
-            FROM ordered_messages m
-            WHERE m.id = ANY($2)
-            OR EXISTS (
-              SELECT 1 FROM ordered_messages target
-              WHERE target.id = ANY($2)
-              AND (
-                -- Get previous messages based on the max withPreviousMessages
-                (m.row_num <= target.row_num + $3 AND m.row_num > target.row_num)
-                OR
-                -- Get next messages based on the max withNextMessages
-                (m.row_num >= target.row_num - $4 AND m.row_num < target.row_num)
+        const unionQueries = [];
+        const params = [];
+        let paramIdx = 1;
+        for (const inc of include) {
+          const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+          const searchId = inc.threadId || threadId;
+          unionQueries.push(
+            `
+            SELECT * FROM (
+              WITH ordered_messages AS (
+                SELECT 
+                  *,
+                  ROW_NUMBER() OVER (${orderByStatement}) as row_num
+                FROM ${this.getTableName(storage.TABLE_MESSAGES)}
+                WHERE thread_id = $${paramIdx}
               )
-            )
-            ORDER BY m."createdAt" ASC 
-            `,
-          // Keep ASC for final sorting after fetching context
-          [
-            threadId,
-            include.map((i) => i.id),
-            Math.max(0, ...include.map((i) => i.withPreviousMessages || 0)),
-            // Ensure non-negative
-            Math.max(0, ...include.map((i) => i.withNextMessages || 0))
-            // Ensure non-negative
-          ]
+              SELECT
+                m.id, 
+                m.content, 
+                m.role, 
+                m.type,
+                m."createdAt", 
+                m.thread_id AS "threadId",
+                m."resourceId"
+              FROM ordered_messages m
+              WHERE m.id = $${paramIdx + 1}
+              OR EXISTS (
+                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)
+                  OR
+                  -- Get next messages based on the max withNextMessages
+                  (m.row_num >= target.row_num - $${paramIdx + 3} AND m.row_num < target.row_num)
+                )
+              )
+            ) 
+            `
+            // Keep ASC for final sorting after fetching context
+          );
+          params.push(searchId, id, withPreviousMessages, withNextMessages);
+          paramIdx += 4;
+        }
+        const finalQuery = unionQueries.join(" UNION ALL ") + ' ORDER BY "createdAt" ASC';
+        const includedRows = await this.db.manyOrNone(finalQuery, params);
+        const dedupedRows = Object.values(
+          includedRows.reduce(
+            (acc, row) => {
+              acc[row.id] = row;
+              return acc;
+            },
+            {}
+          )
         );
+        rows = dedupedRows;
       } else {
         const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
         if (limit === 0 && selectBy?.last !== false) ; else {
@@ -1578,16 +1598,27 @@ var PostgresStore = class extends storage.MastraStorage {
       }
       await this.db.tx(async (t) => {
         for (const message of messages) {
+          if (!message.threadId) {
+            throw new Error(
+              `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`
+            );
+          }
+          if (!message.resourceId) {
+            throw new Error(
+              `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`
+            );
+          }
           await t.none(
-            `INSERT INTO ${this.getTableName(storage.TABLE_MESSAGES)} (id, thread_id, content, "createdAt", role, type) 
-             VALUES ($1, $2, $3, $4, $5, $6)`,
+            `INSERT INTO ${this.getTableName(storage.TABLE_MESSAGES)} (id, thread_id, content, "createdAt", role, type, "resourceId") 
+             VALUES ($1, $2, $3, $4, $5, $6, $7)`,
             [
               message.id,
-              threadId,
+              message.threadId,
               typeof message.content === "string" ? message.content : JSON.stringify(message.content),
               message.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
               message.role,
-              message.type || "v2"
+              message.type || "v2",
+              message.resourceId
             ]
           );
         }

package/dist/index.js

@@ -936,6 +936,11 @@ var PostgresStore = class extends MastraStorage {
       }
     );
   }
+  get supports() {
+    return {
+      selectByIncludeResourceScope: true
+    };
+  }
   getTableName(indexName) {
     const parsedIndexName = parseSqlIdentifier(indexName, "table name");
     const parsedSchemaName = this.schema ? parseSqlIdentifier(this.schema, "schema name") : void 0;
@@ -1426,47 +1431,62 @@ var PostgresStore = class extends MastraStorage {
       let rows = [];
       const include = selectBy?.include || [];
       if (include.length) {
-        rows = await this.db.manyOrNone(
-          `
-            WITH ordered_messages AS (
-              SELECT 
-                *,
-                ROW_NUMBER() OVER (${orderByStatement}) as row_num
-              FROM ${this.getTableName(TABLE_MESSAGES)}
-              WHERE thread_id = $1
-            )
-            SELECT
-              m.id, 
-              m.content, 
-              m.role, 
-              m.type,
-              m."createdAt", 
-              m.thread_id AS "threadId"
-            FROM ordered_messages m
-            WHERE m.id = ANY($2)
-            OR EXISTS (
-              SELECT 1 FROM ordered_messages target
-              WHERE target.id = ANY($2)
-              AND (
-                -- Get previous messages based on the max withPreviousMessages
-                (m.row_num <= target.row_num + $3 AND m.row_num > target.row_num)
-                OR
-                -- Get next messages based on the max withNextMessages
-                (m.row_num >= target.row_num - $4 AND m.row_num < target.row_num)
+        const unionQueries = [];
+        const params = [];
+        let paramIdx = 1;
+        for (const inc of include) {
+          const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+          const searchId = inc.threadId || threadId;
+          unionQueries.push(
+            `
+            SELECT * FROM (
+              WITH ordered_messages AS (
+                SELECT 
+                  *,
+                  ROW_NUMBER() OVER (${orderByStatement}) as row_num
+                FROM ${this.getTableName(TABLE_MESSAGES)}
+                WHERE thread_id = $${paramIdx}
               )
-            )
-            ORDER BY m."createdAt" ASC 
-            `,
-          // Keep ASC for final sorting after fetching context
-          [
-            threadId,
-            include.map((i) => i.id),
-            Math.max(0, ...include.map((i) => i.withPreviousMessages || 0)),
-            // Ensure non-negative
-            Math.max(0, ...include.map((i) => i.withNextMessages || 0))
-            // Ensure non-negative
-          ]
+              SELECT
+                m.id, 
+                m.content, 
+                m.role, 
+                m.type,
+                m."createdAt", 
+                m.thread_id AS "threadId",
+                m."resourceId"
+              FROM ordered_messages m
+              WHERE m.id = $${paramIdx + 1}
+              OR EXISTS (
+                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)
+                  OR
+                  -- Get next messages based on the max withNextMessages
+                  (m.row_num >= target.row_num - $${paramIdx + 3} AND m.row_num < target.row_num)
+                )
+              )
+            ) 
+            `
+            // Keep ASC for final sorting after fetching context
+          );
+          params.push(searchId, id, withPreviousMessages, withNextMessages);
+          paramIdx += 4;
+        }
+        const finalQuery = unionQueries.join(" UNION ALL ") + ' ORDER BY "createdAt" ASC';
+        const includedRows = await this.db.manyOrNone(finalQuery, params);
+        const dedupedRows = Object.values(
+          includedRows.reduce(
+            (acc, row) => {
+              acc[row.id] = row;
+              return acc;
+            },
+            {}
+          )
         );
+        rows = dedupedRows;
       } else {
         const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
         if (limit === 0 && selectBy?.last !== false) ; else {
@@ -1570,16 +1590,27 @@ var PostgresStore = class extends MastraStorage {
       }
       await this.db.tx(async (t) => {
         for (const message of messages) {
+          if (!message.threadId) {
+            throw new Error(
+              `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`
+            );
+          }
+          if (!message.resourceId) {
+            throw new Error(
+              `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`
+            );
+          }
           await t.none(
-            `INSERT INTO ${this.getTableName(TABLE_MESSAGES)} (id, thread_id, content, "createdAt", role, type) 
-             VALUES ($1, $2, $3, $4, $5, $6)`,
+            `INSERT INTO ${this.getTableName(TABLE_MESSAGES)} (id, thread_id, content, "createdAt", role, type, "resourceId") 
+             VALUES ($1, $2, $3, $4, $5, $6, $7)`,
             [
               message.id,
-              threadId,
+              message.threadId,
               typeof message.content === "string" ? message.content : JSON.stringify(message.content),
               message.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
               message.role,
-              message.type || "v2"
+              message.type || "v2",
+              message.resourceId
             ]
           );
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pg",
-  "version": "0.10.2-alpha.1",
+  "version": "0.10.2-alpha.2",
   "description": "Postgres provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -34,8 +34,8 @@
     "typescript": "^5.8.2",
     "vitest": "^3.2.2",
     "@internal/lint": "0.0.10",
-    "@internal/storage-test-utils": "0.0.6",
-    "@mastra/core": "0.10.4-alpha.1"
+    "@mastra/core": "0.10.4-alpha.2",
+    "@internal/storage-test-utils": "0.0.6"
   },
   "peerDependencies": {
     "@mastra/core": "^0.10.2-alpha.0"

package/src/storage/index.test.ts

@@ -7,8 +7,9 @@ import {
   createSampleMessageV2,
   createSampleWorkflowSnapshot,
   resetRole,
+  checkWorkflowSnapshot,
 } from '@internal/storage-test-utils';
-import type { MastraMessageV1, StorageThreadType } from '@mastra/core/memory';
+import type { MastraMessageV1, MastraMessageV2, StorageThreadType } from '@mastra/core/memory';
 import type { StorageColumn, TABLE_NAMES } from '@mastra/core/storage';
 import {
   TABLE_WORKFLOW_SNAPSHOT,
@@ -36,13 +37,6 @@ const connectionString = `postgresql://${TEST_CONFIG.user}:${TEST_CONFIG.passwor
 
 vi.setConfig({ testTimeout: 60_000, hookTimeout: 60_000 });
 
-const checkWorkflowSnapshot = (snapshot: WorkflowRunState | string, stepId: string, status: string) => {
-  if (typeof snapshot === 'string') {
-    throw new Error('Expected WorkflowRunState, got string');
-  }
-  expect(snapshot.context?.[stepId]?.status).toBe(status);
-};
-
 describe('PostgresStore', () => {
   let store: PostgresStore;
 
@@ -241,6 +235,110 @@ describe('PostgresStore', () => {
       const savedMessages = await store.getMessages({ threadId: thread.id });
       expect(savedMessages).toHaveLength(0);
     });
+
+    it('should retrieve messages w/ next/prev messages by message id + resource id', async () => {
+      const thread = createSampleThread({ id: 'thread-one' });
+      await store.saveThread({ thread });
+
+      const thread2 = createSampleThread({ id: 'thread-two' });
+      await store.saveThread({ thread: thread2 });
+
+      const thread3 = createSampleThread({ id: 'thread-three' });
+      await store.saveThread({ thread: thread3 });
+
+      const messages: MastraMessageV2[] = [
+        createSampleMessageV2({ threadId: 'thread-one', content: 'First', resourceId: 'cross-thread-resource' }),
+        createSampleMessageV2({ threadId: 'thread-one', content: 'Second', resourceId: 'cross-thread-resource' }),
+        createSampleMessageV2({ threadId: 'thread-one', content: 'Third', resourceId: 'cross-thread-resource' }),
+
+        createSampleMessageV2({ threadId: 'thread-two', content: 'Fourth', resourceId: 'cross-thread-resource' }),
+        createSampleMessageV2({ threadId: 'thread-two', content: 'Fifth', resourceId: 'cross-thread-resource' }),
+        createSampleMessageV2({ threadId: 'thread-two', content: 'Sixth', resourceId: 'cross-thread-resource' }),
+
+        createSampleMessageV2({ threadId: 'thread-three', content: 'Seventh', resourceId: 'other-resource' }),
+        createSampleMessageV2({ threadId: 'thread-three', content: 'Eighth', resourceId: 'other-resource' }),
+      ];
+
+      await store.saveMessages({ messages: messages, format: 'v2' });
+
+      const retrievedMessages = await store.getMessages({ threadId: 'thread-one', format: 'v2' });
+      expect(retrievedMessages).toHaveLength(3);
+      expect(retrievedMessages.map((m: any) => m.content.parts[0].text)).toEqual(['First', 'Second', 'Third']);
+
+      const retrievedMessages2 = await store.getMessages({ threadId: 'thread-two', format: 'v2' });
+      expect(retrievedMessages2).toHaveLength(3);
+      expect(retrievedMessages2.map((m: any) => m.content.parts[0].text)).toEqual(['Fourth', 'Fifth', 'Sixth']);
+
+      const retrievedMessages3 = await store.getMessages({ threadId: 'thread-three', format: 'v2' });
+      expect(retrievedMessages3).toHaveLength(2);
+      expect(retrievedMessages3.map((m: any) => m.content.parts[0].text)).toEqual(['Seventh', 'Eighth']);
+
+      const crossThreadMessages: MastraMessageV2[] = await store.getMessages({
+        threadId: 'thread-doesnt-exist',
+        format: 'v2',
+        selectBy: {
+          last: 0,
+          include: [
+            {
+              id: messages[1].id,
+              threadId: 'thread-one',
+              withNextMessages: 2,
+              withPreviousMessages: 2,
+            },
+            {
+              id: messages[4].id,
+              threadId: 'thread-two',
+              withPreviousMessages: 2,
+              withNextMessages: 2,
+            },
+          ],
+        },
+      });
+
+      expect(crossThreadMessages).toHaveLength(6);
+      expect(crossThreadMessages.filter(m => m.threadId === `thread-one`)).toHaveLength(3);
+      expect(crossThreadMessages.filter(m => m.threadId === `thread-two`)).toHaveLength(3);
+
+      const crossThreadMessages2: MastraMessageV2[] = await store.getMessages({
+        threadId: 'thread-one',
+        format: 'v2',
+        selectBy: {
+          last: 0,
+          include: [
+            {
+              id: messages[4].id,
+              threadId: 'thread-two',
+              withPreviousMessages: 1,
+              withNextMessages: 1,
+            },
+          ],
+        },
+      });
+
+      expect(crossThreadMessages2).toHaveLength(3);
+      expect(crossThreadMessages2.filter(m => m.threadId === `thread-one`)).toHaveLength(0);
+      expect(crossThreadMessages2.filter(m => m.threadId === `thread-two`)).toHaveLength(3);
+
+      const crossThreadMessages3: MastraMessageV2[] = await store.getMessages({
+        threadId: 'thread-two',
+        format: 'v2',
+        selectBy: {
+          last: 0,
+          include: [
+            {
+              id: messages[1].id,
+              threadId: 'thread-one',
+              withNextMessages: 1,
+              withPreviousMessages: 1,
+            },
+          ],
+        },
+      });
+
+      expect(crossThreadMessages3).toHaveLength(3);
+      expect(crossThreadMessages3.filter(m => m.threadId === `thread-one`)).toHaveLength(3);
+      expect(crossThreadMessages3.filter(m => m.threadId === `thread-two`)).toHaveLength(0);
+    });
   });
 
   describe('Edge Cases and Error Handling', () => {
@@ -1279,6 +1377,7 @@ describe('PostgresStore', () => {
       });
 
       it('should filter by date with pagination for getMessages', async () => {
+        resetRole();
         const threadData = createSampleThread();
         const thread = await store.saveThread({ thread: threadData as StorageThreadType });
         const now = new Date();

package/src/storage/index.ts

@@ -87,6 +87,14 @@ export class PostgresStore extends MastraStorage {
     );
   }
 
+  public get supports(): {
+    selectByIncludeResourceScope: boolean;
+  } {
+    return {
+      selectByIncludeResourceScope: true,
+    };
+  }
+
   private getTableName(indexName: string) {
     const parsedIndexName = parseSqlIdentifier(indexName, 'table name');
     const parsedSchemaName = this.schema ? parseSqlIdentifier(this.schema, 'schema name') : undefined;
@@ -706,44 +714,63 @@ export class PostgresStore extends MastraStorage {
       const include = selectBy?.include || [];
 
       if (include.length) {
-        rows = await this.db.manyOrNone(
-          `
-            WITH ordered_messages AS (
-              SELECT 
-                *,
-                ROW_NUMBER() OVER (${orderByStatement}) as row_num
-              FROM ${this.getTableName(TABLE_MESSAGES)}
-              WHERE thread_id = $1
-            )
-            SELECT
-              m.id, 
-              m.content, 
-              m.role, 
-              m.type,
-              m."createdAt", 
-              m.thread_id AS "threadId"
-            FROM ordered_messages m
-            WHERE m.id = ANY($2)
-            OR EXISTS (
-              SELECT 1 FROM ordered_messages target
-              WHERE target.id = ANY($2)
-              AND (
-                -- Get previous messages based on the max withPreviousMessages
-                (m.row_num <= target.row_num + $3 AND m.row_num > target.row_num)
-                OR
-                -- Get next messages based on the max withNextMessages
-                (m.row_num >= target.row_num - $4 AND m.row_num < target.row_num)
+        const unionQueries: string[] = [];
+        const params: any[] = [];
+        let paramIdx = 1;
+
+        for (const inc of include) {
+          const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+          // if threadId is provided, use it, otherwise use threadId from args
+          const searchId = inc.threadId || threadId;
+          unionQueries.push(
+            `
+            SELECT * FROM (
+              WITH ordered_messages AS (
+                SELECT 
+                  *,
+                  ROW_NUMBER() OVER (${orderByStatement}) as row_num
+                FROM ${this.getTableName(TABLE_MESSAGES)}
+                WHERE thread_id = $${paramIdx}
               )
-            )
-            ORDER BY m."createdAt" ASC 
+              SELECT
+                m.id, 
+                m.content, 
+                m.role, 
+                m.type,
+                m."createdAt", 
+                m.thread_id AS "threadId",
+                m."resourceId"
+              FROM ordered_messages m
+              WHERE m.id = $${paramIdx + 1}
+              OR EXISTS (
+                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)
+                  OR
+                  -- Get next messages based on the max withNextMessages
+                  (m.row_num >= target.row_num - $${paramIdx + 3} AND m.row_num < target.row_num)
+                )
+              )
+            ) 
             `, // Keep ASC for final sorting after fetching context
-          [
-            threadId,
-            include.map(i => i.id),
-            Math.max(0, ...include.map(i => i.withPreviousMessages || 0)), // Ensure non-negative
-            Math.max(0, ...include.map(i => i.withNextMessages || 0)), // Ensure non-negative
-          ],
+          );
+          params.push(searchId, id, withPreviousMessages, withNextMessages);
+          paramIdx += 4;
+        }
+        const finalQuery = unionQueries.join(' UNION ALL ') + ' ORDER BY "createdAt" ASC';
+        const includedRows = await this.db.manyOrNone(finalQuery, params);
+        const dedupedRows = Object.values(
+          includedRows.reduce(
+            (acc, row) => {
+              acc[row.id] = row;
+              return acc;
+            },
+            {} as Record<string, (typeof includedRows)[0]>,
+          ),
         );
+        rows = dedupedRows;
       } else {
         const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
         if (limit === 0 && selectBy?.last !== false) {
@@ -881,16 +908,27 @@ export class PostgresStore extends MastraStorage {
 
       await this.db.tx(async t => {
         for (const message of messages) {
+          if (!message.threadId) {
+            throw new Error(
+              `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`,
+            );
+          }
+          if (!message.resourceId) {
+            throw new Error(
+              `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`,
+            );
+          }
           await t.none(
-            `INSERT INTO ${this.getTableName(TABLE_MESSAGES)} (id, thread_id, content, "createdAt", role, type) 
-             VALUES ($1, $2, $3, $4, $5, $6)`,
+            `INSERT INTO ${this.getTableName(TABLE_MESSAGES)} (id, thread_id, content, "createdAt", role, type, "resourceId") 
+             VALUES ($1, $2, $3, $4, $5, $6, $7)`,
             [
               message.id,
-              threadId,
+              message.threadId,
               typeof message.content === 'string' ? message.content : JSON.stringify(message.content),
               message.createdAt || new Date().toISOString(),
               message.role,
               message.type || 'v2',
+              message.resourceId,
             ],
           );
         }