@mastra/pg 0.11.0 → 0.11.1-alpha.0

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/pg@0.11.0-alpha.3 build /home/runner/work/mastra/mastra/stores/pg
+> @mastra/pg@0.11.1-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 10202ms
+TSC ⚡️ Build success in 11031ms
 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 11263ms
+DTS ⚡️ Build success in 11090ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 67.91 KB
-ESM ⚡️ Build success in 2081ms
-CJS dist/index.cjs 68.48 KB
-CJS ⚡️ Build success in 2081ms
+ESM dist/index.js 71.25 KB
+ESM ⚡️ Build success in 1507ms
+CJS dist/index.cjs 71.84 KB
+CJS ⚡️ Build success in 1506ms

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @mastra/pg
 
+## 0.11.1-alpha.0
+
+### Patch Changes
+
+- d8f2d19: Add updateMessages API to storage classes (only support for PG and LibSQL for now) and to memory class. Additionally allow for metadata to be saved in the content field of a message.
+- Updated dependencies [d8f2d19]
+- Updated dependencies [9d52b17]
+- Updated dependencies [8ba1b51]
+  - @mastra/core@0.10.7-alpha.0
+
 ## 0.11.0
 
 ### Minor Changes

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

@@ -6,6 +6,7 @@ import type { DescribeIndexParams } from '@mastra/core/vector';
 import type { EvalRow } from '@mastra/core/storage';
 import type { IndexStats } from '@mastra/core/vector';
 import type { ISSLConfig } from 'pg-promise/typescript/pg-subset';
+import type { MastraMessageContentV2 } from '@mastra/core/agent';
 import type { MastraMessageV1 } from '@mastra/core/memory';
 import type { MastraMessageV2 } from '@mastra/core/agent';
 import { MastraStorage } from '@mastra/core/storage';
@@ -411,6 +412,15 @@ declare class PostgresStore extends MastraStorage {
     } & PaginationArgs): Promise<PaginationInfo & {
         evals: EvalRow[];
     }>;
+    updateMessages({ messages, }: {
+        messages: (Partial<Omit<MastraMessageV2, 'createdAt'>> & {
+            id: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        })[];
+    }): Promise<MastraMessageV2[]>;
 }
 export { PostgresStore }
 export { PostgresStore as PostgresStore_alias_1 }

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

@@ -6,6 +6,7 @@ import type { DescribeIndexParams } from '@mastra/core/vector';
 import type { EvalRow } from '@mastra/core/storage';
 import type { IndexStats } from '@mastra/core/vector';
 import type { ISSLConfig } from 'pg-promise/typescript/pg-subset';
+import type { MastraMessageContentV2 } from '@mastra/core/agent';
 import type { MastraMessageV1 } from '@mastra/core/memory';
 import type { MastraMessageV2 } from '@mastra/core/agent';
 import { MastraStorage } from '@mastra/core/storage';
@@ -411,6 +412,15 @@ declare class PostgresStore extends MastraStorage {
     } & PaginationArgs): Promise<PaginationInfo & {
         evals: EvalRow[];
     }>;
+    updateMessages({ messages, }: {
+        messages: (Partial<Omit<MastraMessageV2, 'createdAt'>> & {
+            id: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        })[];
+    }): Promise<MastraMessageV2[]>;
 }
 export { PostgresStore }
 export { PostgresStore as PostgresStore_alias_1 }

package/dist/index.cjs

@@ -1869,6 +1869,101 @@ var PostgresStore = class extends storage.MastraStorage {
       hasMore: currentOffset + (rows?.length ?? 0) < total
     };
   }
+  async updateMessages({
+    messages
+  }) {
+    if (messages.length === 0) {
+      return [];
+    }
+    const messageIds = messages.map((m) => m.id);
+    const selectQuery = `SELECT id, content, role, type, "createdAt", thread_id AS "threadId", "resourceId" FROM ${this.getTableName(
+      storage.TABLE_MESSAGES
+    )} WHERE id IN ($1:list)`;
+    const existingMessagesDb = await this.db.manyOrNone(selectQuery, [messageIds]);
+    if (existingMessagesDb.length === 0) {
+      return [];
+    }
+    const existingMessages = existingMessagesDb.map((msg) => {
+      if (typeof msg.content === "string") {
+        try {
+          msg.content = JSON.parse(msg.content);
+        } catch {
+        }
+      }
+      return msg;
+    });
+    const threadIdsToUpdate = /* @__PURE__ */ new Set();
+    await this.db.tx(async (t) => {
+      const queries = [];
+      const columnMapping = {
+        threadId: "thread_id"
+      };
+      for (const existingMessage of existingMessages) {
+        const updatePayload = messages.find((m) => m.id === existingMessage.id);
+        if (!updatePayload) continue;
+        const { id, ...fieldsToUpdate } = updatePayload;
+        if (Object.keys(fieldsToUpdate).length === 0) continue;
+        threadIdsToUpdate.add(existingMessage.threadId);
+        if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+          threadIdsToUpdate.add(updatePayload.threadId);
+        }
+        const setClauses = [];
+        const values = [];
+        let paramIndex = 1;
+        const updatableFields = { ...fieldsToUpdate };
+        if (updatableFields.content) {
+          const newContent = {
+            ...existingMessage.content,
+            ...updatableFields.content,
+            // Deep merge metadata if it exists on both
+            ...existingMessage.content?.metadata && updatableFields.content.metadata ? {
+              metadata: {
+                ...existingMessage.content.metadata,
+                ...updatableFields.content.metadata
+              }
+            } : {}
+          };
+          setClauses.push(`content = $${paramIndex++}`);
+          values.push(newContent);
+          delete updatableFields.content;
+        }
+        for (const key in updatableFields) {
+          if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+            const dbColumn = columnMapping[key] || key;
+            setClauses.push(`"${dbColumn}" = $${paramIndex++}`);
+            values.push(updatableFields[key]);
+          }
+        }
+        if (setClauses.length > 0) {
+          values.push(id);
+          const sql = `UPDATE ${this.getTableName(
+            storage.TABLE_MESSAGES
+          )} SET ${setClauses.join(", ")} WHERE id = $${paramIndex}`;
+          queries.push(t.none(sql, values));
+        }
+      }
+      if (threadIdsToUpdate.size > 0) {
+        queries.push(
+          t.none(`UPDATE ${this.getTableName(storage.TABLE_THREADS)} SET "updatedAt" = NOW() WHERE id IN ($1:list)`, [
+            Array.from(threadIdsToUpdate)
+          ])
+        );
+      }
+      if (queries.length > 0) {
+        await t.batch(queries);
+      }
+    });
+    const updatedMessages = await this.db.manyOrNone(selectQuery, [messageIds]);
+    return (updatedMessages || []).map((message) => {
+      if (typeof message.content === "string") {
+        try {
+          message.content = JSON.parse(message.content);
+        } catch {
+        }
+      }
+      return message;
+    });
+  }
 };
 
 // src/vector/prompt.ts

package/dist/index.js

@@ -1861,6 +1861,101 @@ var PostgresStore = class extends MastraStorage {
       hasMore: currentOffset + (rows?.length ?? 0) < total
     };
   }
+  async updateMessages({
+    messages
+  }) {
+    if (messages.length === 0) {
+      return [];
+    }
+    const messageIds = messages.map((m) => m.id);
+    const selectQuery = `SELECT id, content, role, type, "createdAt", thread_id AS "threadId", "resourceId" FROM ${this.getTableName(
+      TABLE_MESSAGES
+    )} WHERE id IN ($1:list)`;
+    const existingMessagesDb = await this.db.manyOrNone(selectQuery, [messageIds]);
+    if (existingMessagesDb.length === 0) {
+      return [];
+    }
+    const existingMessages = existingMessagesDb.map((msg) => {
+      if (typeof msg.content === "string") {
+        try {
+          msg.content = JSON.parse(msg.content);
+        } catch {
+        }
+      }
+      return msg;
+    });
+    const threadIdsToUpdate = /* @__PURE__ */ new Set();
+    await this.db.tx(async (t) => {
+      const queries = [];
+      const columnMapping = {
+        threadId: "thread_id"
+      };
+      for (const existingMessage of existingMessages) {
+        const updatePayload = messages.find((m) => m.id === existingMessage.id);
+        if (!updatePayload) continue;
+        const { id, ...fieldsToUpdate } = updatePayload;
+        if (Object.keys(fieldsToUpdate).length === 0) continue;
+        threadIdsToUpdate.add(existingMessage.threadId);
+        if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+          threadIdsToUpdate.add(updatePayload.threadId);
+        }
+        const setClauses = [];
+        const values = [];
+        let paramIndex = 1;
+        const updatableFields = { ...fieldsToUpdate };
+        if (updatableFields.content) {
+          const newContent = {
+            ...existingMessage.content,
+            ...updatableFields.content,
+            // Deep merge metadata if it exists on both
+            ...existingMessage.content?.metadata && updatableFields.content.metadata ? {
+              metadata: {
+                ...existingMessage.content.metadata,
+                ...updatableFields.content.metadata
+              }
+            } : {}
+          };
+          setClauses.push(`content = $${paramIndex++}`);
+          values.push(newContent);
+          delete updatableFields.content;
+        }
+        for (const key in updatableFields) {
+          if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+            const dbColumn = columnMapping[key] || key;
+            setClauses.push(`"${dbColumn}" = $${paramIndex++}`);
+            values.push(updatableFields[key]);
+          }
+        }
+        if (setClauses.length > 0) {
+          values.push(id);
+          const sql = `UPDATE ${this.getTableName(
+            TABLE_MESSAGES
+          )} SET ${setClauses.join(", ")} WHERE id = $${paramIndex}`;
+          queries.push(t.none(sql, values));
+        }
+      }
+      if (threadIdsToUpdate.size > 0) {
+        queries.push(
+          t.none(`UPDATE ${this.getTableName(TABLE_THREADS)} SET "updatedAt" = NOW() WHERE id IN ($1:list)`, [
+            Array.from(threadIdsToUpdate)
+          ])
+        );
+      }
+      if (queries.length > 0) {
+        await t.batch(queries);
+      }
+    });
+    const updatedMessages = await this.db.manyOrNone(selectQuery, [messageIds]);
+    return (updatedMessages || []).map((message) => {
+      if (typeof message.content === "string") {
+        try {
+          message.content = JSON.parse(message.content);
+        } catch {
+        }
+      }
+      return message;
+    });
+  }
 };
 
 // src/vector/prompt.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/pg",
-  "version": "0.11.0",
+  "version": "0.11.1-alpha.0",
   "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.3",
     "vitest": "^3.2.3",
     "@internal/lint": "0.0.13",
-    "@mastra/core": "0.10.6",
-    "@internal/storage-test-utils": "0.0.9"
+    "@internal/storage-test-utils": "0.0.9",
+    "@mastra/core": "0.10.7-alpha.0"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.4-0 <0.11.0"

package/src/storage/index.test.ts

@@ -4,12 +4,12 @@ import {
   createSampleTraceForDB,
   createSampleThread,
   createSampleMessageV1,
-  createSampleMessageV2,
   createSampleWorkflowSnapshot,
   resetRole,
   checkWorkflowSnapshot,
 } from '@internal/storage-test-utils';
-import type { MastraMessageV1, MastraMessageV2, StorageThreadType } from '@mastra/core/memory';
+import type { MastraMessageContentV2, MastraMessageV2 } from '@mastra/core/agent';
+import type { MastraMessageV1, StorageThreadType } from '@mastra/core/memory';
 import type { StorageColumn, TABLE_NAMES } from '@mastra/core/storage';
 import {
   TABLE_WORKFLOW_SNAPSHOT,
@@ -37,6 +37,37 @@ const connectionString = `postgresql://${TEST_CONFIG.user}:${TEST_CONFIG.passwor
 
 vi.setConfig({ testTimeout: 60_000, hookTimeout: 60_000 });
 
+const createSampleMessageV2 = ({
+  threadId,
+  resourceId,
+  role = 'user',
+  content,
+  createdAt,
+  thread,
+}: {
+  threadId: string;
+  resourceId?: string;
+  role?: 'user' | 'assistant';
+  content?: Partial<MastraMessageContentV2>;
+  createdAt?: Date;
+  thread?: StorageThreadType;
+}): MastraMessageV2 => {
+  return {
+    id: randomUUID(),
+    threadId,
+    resourceId: resourceId || thread?.resourceId || 'test-resource',
+    role,
+    createdAt: createdAt || new Date(),
+    content: {
+      format: 2,
+      parts: content?.parts || [{ type: 'text', text: content?.content ?? '' }],
+      content: content?.content || `Sample content ${randomUUID()}`,
+      ...content,
+    },
+    type: 'v2',
+  };
+};
+
 describe('PostgresStore', () => {
   let store: PostgresStore;
 
@@ -229,7 +260,9 @@ describe('PostgresStore', () => {
 
       const messageContent = ['First', 'Second', 'Third'];
 
-      const messages = messageContent.map(content => createSampleMessageV2({ threadId: thread.id, content }));
+      const messages = messageContent.map(content =>
+        createSampleMessageV2({ threadId: thread.id, content: { content, parts: [{ type: 'text', text: content }] } }),
+      );
 
       await store.saveMessages({ messages, format: 'v2' });
 
@@ -269,16 +302,48 @@ describe('PostgresStore', () => {
       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-one',
+          content: { content: 'First' },
+          resourceId: 'cross-thread-resource',
+        }),
+        createSampleMessageV2({
+          threadId: 'thread-one',
+          content: { content: 'Second' },
+          resourceId: 'cross-thread-resource',
+        }),
+        createSampleMessageV2({
+          threadId: 'thread-one',
+          content: { 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-two',
+          content: { content: 'Fourth' },
+          resourceId: 'cross-thread-resource',
+        }),
+        createSampleMessageV2({
+          threadId: 'thread-two',
+          content: { content: 'Fifth' },
+          resourceId: 'cross-thread-resource',
+        }),
+        createSampleMessageV2({
+          threadId: 'thread-two',
+          content: { content: 'Sixth' },
+          resourceId: 'cross-thread-resource',
+        }),
 
-        createSampleMessageV2({ threadId: 'thread-three', content: 'Seventh', resourceId: 'other-resource' }),
-        createSampleMessageV2({ threadId: 'thread-three', content: 'Eighth', resourceId: 'other-resource' }),
+        createSampleMessageV2({
+          threadId: 'thread-three',
+          content: { content: 'Seventh' },
+          resourceId: 'other-resource',
+        }),
+        createSampleMessageV2({
+          threadId: 'thread-three',
+          content: { content: 'Eighth' },
+          resourceId: 'other-resource',
+        }),
       ];
 
       await store.saveMessages({ messages: messages, format: 'v2' });
@@ -363,6 +428,132 @@ describe('PostgresStore', () => {
     });
   });
 
+  describe('updateMessages', () => {
+    let thread: StorageThreadType;
+
+    beforeEach(async () => {
+      const threadData = createSampleThread();
+      thread = await store.saveThread({ thread: threadData as StorageThreadType });
+    });
+
+    it('should update a single field of a message (e.g., role)', async () => {
+      const originalMessage = createSampleMessageV2({ threadId: thread.id, role: 'user', thread });
+      await store.saveMessages({ messages: [originalMessage], format: 'v2' });
+
+      const updatedMessages = await store.updateMessages({
+        messages: [{ id: originalMessage.id, role: 'assistant' }],
+      });
+
+      expect(updatedMessages).toHaveLength(1);
+      expect(updatedMessages[0].role).toBe('assistant');
+      expect(updatedMessages[0].content).toEqual(originalMessage.content); // Ensure content is unchanged
+    });
+
+    it('should update only the metadata within the content field, preserving other content', async () => {
+      const originalMessage = createSampleMessageV2({
+        threadId: thread.id,
+        content: { content: 'hello world', parts: [{ type: 'text', text: 'hello world' }] },
+        thread,
+      });
+      await store.saveMessages({ messages: [originalMessage], format: 'v2' });
+
+      const newMetadata = { someKey: 'someValue' };
+      await store.updateMessages({
+        messages: [{ id: originalMessage.id, content: { metadata: newMetadata } as any }],
+      });
+
+      const fromDb = await store.getMessages({ threadId: thread.id, format: 'v2' });
+      expect(fromDb[0].content.metadata).toEqual(newMetadata);
+      expect(fromDb[0].content.content).toBe('hello world');
+      expect(fromDb[0].content.parts).toEqual([{ type: 'text', text: 'hello world' }]);
+    });
+
+    it('should deep merge metadata, not overwrite it', async () => {
+      const originalMessage = createSampleMessageV2({
+        threadId: thread.id,
+        content: { metadata: { initial: true }, content: 'old content' },
+        thread,
+      });
+      await store.saveMessages({ messages: [originalMessage], format: 'v2' });
+
+      const newMetadata = { updated: true };
+      await store.updateMessages({
+        messages: [{ id: originalMessage.id, content: { metadata: newMetadata } as any }],
+      });
+
+      const fromDb = await store.getMessages({ threadId: thread.id, format: 'v2' });
+      expect(fromDb[0].content.metadata).toEqual({ initial: true, updated: true });
+    });
+
+    it('should update multiple messages at once', async () => {
+      const msg1 = createSampleMessageV2({ threadId: thread.id, role: 'user', thread });
+      const msg2 = createSampleMessageV2({ threadId: thread.id, content: { content: 'original' }, thread });
+      await store.saveMessages({ messages: [msg1, msg2], format: 'v2' });
+
+      await store.updateMessages({
+        messages: [
+          { id: msg1.id, role: 'assistant' },
+          { id: msg2.id, content: { content: 'updated' } as any },
+        ],
+      });
+
+      const fromDb = await store.getMessages({ threadId: thread.id, format: 'v2' });
+      const updatedMsg1 = fromDb.find(m => m.id === msg1.id)!;
+      const updatedMsg2 = fromDb.find(m => m.id === msg2.id)!;
+
+      expect(updatedMsg1.role).toBe('assistant');
+      expect(updatedMsg2.content.content).toBe('updated');
+    });
+
+    it('should update the parent thread updatedAt timestamp', async () => {
+      const originalMessage = createSampleMessageV2({ threadId: thread.id, thread });
+      await store.saveMessages({ messages: [originalMessage], format: 'v2' });
+      const initialThread = await store.getThreadById({ threadId: thread.id });
+
+      await new Promise(r => setTimeout(r, 10));
+
+      await store.updateMessages({ messages: [{ id: originalMessage.id, role: 'assistant' }] });
+
+      const updatedThread = await store.getThreadById({ threadId: thread.id });
+
+      expect(new Date(updatedThread!.updatedAt).getTime()).toBeGreaterThan(
+        new Date(initialThread!.updatedAt).getTime(),
+      );
+    });
+
+    it('should update timestamps on both threads when moving a message', async () => {
+      const thread2 = await store.saveThread({ thread: createSampleThread() });
+      const message = createSampleMessageV2({ threadId: thread.id, thread });
+      await store.saveMessages({ messages: [message], format: 'v2' });
+
+      const initialThread1 = await store.getThreadById({ threadId: thread.id });
+      const initialThread2 = await store.getThreadById({ threadId: thread2.id });
+
+      await new Promise(r => setTimeout(r, 10));
+
+      await store.updateMessages({
+        messages: [{ id: message.id, threadId: thread2.id }],
+      });
+
+      const updatedThread1 = await store.getThreadById({ threadId: thread.id });
+      const updatedThread2 = await store.getThreadById({ threadId: thread2.id });
+
+      expect(new Date(updatedThread1!.updatedAt).getTime()).toBeGreaterThan(
+        new Date(initialThread1!.updatedAt).getTime(),
+      );
+      expect(new Date(updatedThread2!.updatedAt).getTime()).toBeGreaterThan(
+        new Date(initialThread2!.updatedAt).getTime(),
+      );
+
+      // Verify the message was moved
+      const thread1Messages = await store.getMessages({ threadId: thread.id, format: 'v2' });
+      const thread2Messages = await store.getMessages({ threadId: thread2.id, format: 'v2' });
+      expect(thread1Messages).toHaveLength(0);
+      expect(thread2Messages).toHaveLength(1);
+      expect(thread2Messages[0].id).toBe(message.id);
+    });
+  });
+
   describe('Edge Cases and Error Handling', () => {
     it('should handle large metadata objects', async () => {
       const thread = createSampleThread();

package/src/storage/index.ts

@@ -1,5 +1,5 @@
 import { MessageList } from '@mastra/core/agent';
-import type { MastraMessageV2 } from '@mastra/core/agent';
+import type { MastraMessageContentV2, MastraMessageV2 } from '@mastra/core/agent';
 import type { MetricResult } from '@mastra/core/eval';
 import type { MastraMessageV1, StorageThreadType } from '@mastra/core/memory';
 import {
@@ -1243,4 +1243,134 @@ export class PostgresStore extends MastraStorage {
       hasMore: currentOffset + (rows?.length ?? 0) < total,
     };
   }
+
+  async updateMessages({
+    messages,
+  }: {
+    messages: (Partial<Omit<MastraMessageV2, 'createdAt'>> & {
+      id: string;
+      content?: {
+        metadata?: MastraMessageContentV2['metadata'];
+        content?: MastraMessageContentV2['content'];
+      };
+    })[];
+  }): Promise<MastraMessageV2[]> {
+    if (messages.length === 0) {
+      return [];
+    }
+
+    const messageIds = messages.map(m => m.id);
+
+    const selectQuery = `SELECT id, content, role, type, "createdAt", thread_id AS "threadId", "resourceId" FROM ${this.getTableName(
+      TABLE_MESSAGES,
+    )} WHERE id IN ($1:list)`;
+
+    const existingMessagesDb = await this.db.manyOrNone(selectQuery, [messageIds]);
+
+    if (existingMessagesDb.length === 0) {
+      return [];
+    }
+
+    // Parse content from string to object for merging
+    const existingMessages: MastraMessageV2[] = existingMessagesDb.map(msg => {
+      if (typeof msg.content === 'string') {
+        try {
+          msg.content = JSON.parse(msg.content);
+        } catch {
+          // ignore if not valid json
+        }
+      }
+      return msg as MastraMessageV2;
+    });
+
+    const threadIdsToUpdate = new Set<string>();
+
+    await this.db.tx(async t => {
+      const queries = [];
+      const columnMapping: Record<string, string> = {
+        threadId: 'thread_id',
+      };
+
+      for (const existingMessage of existingMessages) {
+        const updatePayload = messages.find(m => m.id === existingMessage.id);
+        if (!updatePayload) continue;
+
+        const { id, ...fieldsToUpdate } = updatePayload;
+        if (Object.keys(fieldsToUpdate).length === 0) continue;
+
+        threadIdsToUpdate.add(existingMessage.threadId!);
+        if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+          threadIdsToUpdate.add(updatePayload.threadId);
+        }
+
+        const setClauses: string[] = [];
+        const values: any[] = [];
+        let paramIndex = 1;
+
+        const updatableFields = { ...fieldsToUpdate };
+
+        // Special handling for content: merge in code, then update the whole field
+        if (updatableFields.content) {
+          const newContent = {
+            ...existingMessage.content,
+            ...updatableFields.content,
+            // Deep merge metadata if it exists on both
+            ...(existingMessage.content?.metadata && updatableFields.content.metadata
+              ? {
+                  metadata: {
+                    ...existingMessage.content.metadata,
+                    ...updatableFields.content.metadata,
+                  },
+                }
+              : {}),
+          };
+          setClauses.push(`content = $${paramIndex++}`);
+          values.push(newContent);
+          delete updatableFields.content;
+        }
+
+        for (const key in updatableFields) {
+          if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+            const dbColumn = columnMapping[key] || key;
+            setClauses.push(`"${dbColumn}" = $${paramIndex++}`);
+            values.push(updatableFields[key as keyof typeof updatableFields]);
+          }
+        }
+
+        if (setClauses.length > 0) {
+          values.push(id);
+          const sql = `UPDATE ${this.getTableName(
+            TABLE_MESSAGES,
+          )} SET ${setClauses.join(', ')} WHERE id = $${paramIndex}`;
+          queries.push(t.none(sql, values));
+        }
+      }
+
+      if (threadIdsToUpdate.size > 0) {
+        queries.push(
+          t.none(`UPDATE ${this.getTableName(TABLE_THREADS)} SET "updatedAt" = NOW() WHERE id IN ($1:list)`, [
+            Array.from(threadIdsToUpdate),
+          ]),
+        );
+      }
+
+      if (queries.length > 0) {
+        await t.batch(queries);
+      }
+    });
+
+    // Re-fetch to return the fully updated messages
+    const updatedMessages = await this.db.manyOrNone<MastraMessageV2>(selectQuery, [messageIds]);
+
+    return (updatedMessages || []).map(message => {
+      if (typeof message.content === 'string') {
+        try {
+          message.content = JSON.parse(message.content);
+        } catch {
+          /* ignore */
+        }
+      }
+      return message;
+    });
+  }
 }