@mastra/libsql 0.10.3-alpha.0 → 0.10.4-alpha.0

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/libsql@0.10.3-alpha.0 build /home/runner/work/mastra/mastra/stores/libsql
+> @mastra/libsql@0.10.4-alpha.0 build /home/runner/work/mastra/mastra/stores/libsql
 > 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 9305ms
+TSC ⚡️ Build success in 10773ms
 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/libsql/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/libsql/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 12455ms
+DTS ⚡️ Build success in 11908ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 58.84 KB
-CJS ⚡️ Build success in 1634ms
-ESM dist/index.js 58.55 KB
-ESM ⚡️ Build success in 1636ms
+ESM dist/index.js 61.63 KB
+ESM ⚡️ Build success in 1696ms
+CJS dist/index.cjs 61.96 KB
+CJS ⚡️ Build success in 1707ms

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @mastra/libsql
 
+## 0.10.4-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.10.3
+
+### Patch Changes
+
+- 63f6b7d: dependencies updates:
+  - Updated dependency [`@libsql/client@^0.15.9` ↗︎](https://www.npmjs.com/package/@libsql/client/v/0.15.9) (from `^0.15.8`, in `dependencies`)
+- Updated dependencies [63f6b7d]
+- Updated dependencies [12a95fc]
+- Updated dependencies [4b0f8a6]
+- Updated dependencies [51264a5]
+- Updated dependencies [8e6f677]
+- Updated dependencies [d70c420]
+- Updated dependencies [ee9af57]
+- Updated dependencies [36f1c36]
+- Updated dependencies [2a16996]
+- Updated dependencies [10d352e]
+- Updated dependencies [9589624]
+- Updated dependencies [53d3c37]
+- Updated dependencies [751c894]
+- Updated dependencies [577ce3a]
+- Updated dependencies [9260b3a]
+  - @mastra/core@0.10.6
+
 ## 0.10.3-alpha.0
 
 ### Patch 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 { InValue } from '@libsql/client';
+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';
@@ -172,6 +173,15 @@ declare class LibSQLStore extends MastraStorage {
         messages: MastraMessageV2[];
         format: 'v2';
     }): Promise<MastraMessageV2[]>;
+    updateMessages({ messages, }: {
+        messages: (Partial<Omit<MastraMessageV2, 'createdAt'>> & {
+            id: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        })[];
+    }): Promise<MastraMessageV2[]>;
     private transformEvalRow;
     /** @deprecated use getEvals instead */
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;

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 { InValue } from '@libsql/client';
+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';
@@ -172,6 +173,15 @@ declare class LibSQLStore extends MastraStorage {
         messages: MastraMessageV2[];
         format: 'v2';
     }): Promise<MastraMessageV2[]>;
+    updateMessages({ messages, }: {
+        messages: (Partial<Omit<MastraMessageV2, 'createdAt'>> & {
+            id: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        })[];
+    }): Promise<MastraMessageV2[]>;
     private transformEvalRow;
     /** @deprecated use getEvals instead */
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;

package/dist/index.cjs

@@ -1351,6 +1351,85 @@ var LibSQLStore = class extends storage.MastraStorage {
       throw error;
     }
   }
+  async updateMessages({
+    messages
+  }) {
+    if (messages.length === 0) {
+      return [];
+    }
+    const messageIds = messages.map((m) => m.id);
+    const placeholders = messageIds.map(() => "?").join(",");
+    const selectSql = `SELECT * FROM ${storage.TABLE_MESSAGES} WHERE id IN (${placeholders})`;
+    const existingResult = await this.client.execute({ sql: selectSql, args: messageIds });
+    const existingMessages = existingResult.rows.map((row) => this.parseRow(row));
+    if (existingMessages.length === 0) {
+      return [];
+    }
+    const batchStatements = [];
+    const threadIdsToUpdate = /* @__PURE__ */ new Set();
+    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 args = [];
+      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(`${utils.parseSqlIdentifier("content", "column name")} = ?`);
+        args.push(JSON.stringify(newContent));
+        delete updatableFields.content;
+      }
+      for (const key in updatableFields) {
+        if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+          const dbKey = columnMapping[key] || key;
+          setClauses.push(`${utils.parseSqlIdentifier(dbKey, "column name")} = ?`);
+          let value = updatableFields[key];
+          if (typeof value === "object" && value !== null) {
+            value = JSON.stringify(value);
+          }
+          args.push(value);
+        }
+      }
+      if (setClauses.length === 0) continue;
+      args.push(id);
+      const sql = `UPDATE ${storage.TABLE_MESSAGES} SET ${setClauses.join(", ")} WHERE id = ?`;
+      batchStatements.push({ sql, args });
+    }
+    if (batchStatements.length === 0) {
+      return existingMessages;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const threadId of threadIdsToUpdate) {
+      if (threadId) {
+        batchStatements.push({
+          sql: `UPDATE ${storage.TABLE_THREADS} SET updatedAt = ? WHERE id = ?`,
+          args: [now, threadId]
+        });
+      }
+    }
+    await this.client.batch(batchStatements, "write");
+    const updatedResult = await this.client.execute({ sql: selectSql, args: messageIds });
+    return updatedResult.rows.map((row) => this.parseRow(row));
+  }
   transformEvalRow(row) {
     const resultValue = JSON.parse(row.result);
     const testInfoValue = row.test_info ? JSON.parse(row.test_info) : void 0;

package/dist/index.js

@@ -1349,6 +1349,85 @@ var LibSQLStore = class extends MastraStorage {
       throw error;
     }
   }
+  async updateMessages({
+    messages
+  }) {
+    if (messages.length === 0) {
+      return [];
+    }
+    const messageIds = messages.map((m) => m.id);
+    const placeholders = messageIds.map(() => "?").join(",");
+    const selectSql = `SELECT * FROM ${TABLE_MESSAGES} WHERE id IN (${placeholders})`;
+    const existingResult = await this.client.execute({ sql: selectSql, args: messageIds });
+    const existingMessages = existingResult.rows.map((row) => this.parseRow(row));
+    if (existingMessages.length === 0) {
+      return [];
+    }
+    const batchStatements = [];
+    const threadIdsToUpdate = /* @__PURE__ */ new Set();
+    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 args = [];
+      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(`${parseSqlIdentifier("content", "column name")} = ?`);
+        args.push(JSON.stringify(newContent));
+        delete updatableFields.content;
+      }
+      for (const key in updatableFields) {
+        if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+          const dbKey = columnMapping[key] || key;
+          setClauses.push(`${parseSqlIdentifier(dbKey, "column name")} = ?`);
+          let value = updatableFields[key];
+          if (typeof value === "object" && value !== null) {
+            value = JSON.stringify(value);
+          }
+          args.push(value);
+        }
+      }
+      if (setClauses.length === 0) continue;
+      args.push(id);
+      const sql = `UPDATE ${TABLE_MESSAGES} SET ${setClauses.join(", ")} WHERE id = ?`;
+      batchStatements.push({ sql, args });
+    }
+    if (batchStatements.length === 0) {
+      return existingMessages;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const threadId of threadIdsToUpdate) {
+      if (threadId) {
+        batchStatements.push({
+          sql: `UPDATE ${TABLE_THREADS} SET updatedAt = ? WHERE id = ?`,
+          args: [now, threadId]
+        });
+      }
+    }
+    await this.client.batch(batchStatements, "write");
+    const updatedResult = await this.client.execute({ sql: selectSql, args: messageIds });
+    return updatedResult.rows.map((row) => this.parseRow(row));
+  }
   transformEvalRow(row) {
     const resultValue = JSON.parse(row.result);
     const testInfoValue = row.test_info ? JSON.parse(row.test_info) : void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/libsql",
-  "version": "0.10.3-alpha.0",
+  "version": "0.10.4-alpha.0",
   "description": "Libsql provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -29,9 +29,9 @@
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.3",
-    "@internal/lint": "0.0.12",
-    "@internal/storage-test-utils": "0.0.8",
-    "@mastra/core": "0.10.6-alpha.0"
+    "@internal/storage-test-utils": "0.0.9",
+    "@internal/lint": "0.0.13",
+    "@mastra/core": "0.10.7-alpha.0"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.4-0 <0.11.0"

package/src/storage/index.test.ts

@@ -8,6 +8,7 @@ import {
   resetRole,
 } from '@internal/storage-test-utils';
 import type { MastraMessageV1, StorageThreadType } from '@mastra/core';
+import type { MastraMessageV2, MastraMessageContentV2 } from '@mastra/core/agent';
 import { Mastra } from '@mastra/core/mastra';
 import { TABLE_EVALS, TABLE_TRACES, TABLE_MESSAGES, TABLE_THREADS } from '@mastra/core/storage';
 import { describe, it, expect, beforeAll, beforeEach } from 'vitest';
@@ -362,3 +363,196 @@ describe('LibSQLStore Pagination Features', () => {
     });
   });
 });
+
+describe('LibSQLStore updateMessages', () => {
+  let store: LibSQLStore;
+  let thread: StorageThreadType;
+
+  const createSampleMessageV2 = ({
+    threadId,
+    resourceId,
+    role = 'user',
+    content,
+    createdAt,
+  }: {
+    threadId: string;
+    resourceId?: string;
+    role?: 'user' | 'assistant';
+    content?: Partial<MastraMessageContentV2>;
+    createdAt?: Date;
+  }): MastraMessageV2 => {
+    return {
+      id: randomUUID(),
+      threadId,
+      resourceId: resourceId || thread.resourceId,
+      role,
+      createdAt: createdAt || new Date(),
+      content: {
+        format: 2,
+        parts: content?.parts || [],
+        content: content?.content || `Sample content ${randomUUID()}`,
+        ...content,
+      },
+      type: 'v2',
+    };
+  };
+
+  beforeAll(async () => {
+    store = libsql;
+  });
+
+  beforeEach(async () => {
+    await store.clearTable({ tableName: TABLE_MESSAGES });
+    await store.clearTable({ tableName: TABLE_THREADS });
+    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' });
+    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');
+
+    const fromDb = await store.getMessages({ threadId: thread.id, format: 'v2' });
+    expect(fromDb[0].role).toBe('assistant');
+  });
+
+  it('should update only the metadata within the content field, preserving other content fields', async () => {
+    const originalMessage = createSampleMessageV2({
+      threadId: thread.id,
+      content: { content: 'hello world', parts: [{ type: 'text', text: 'hello world' }] },
+    });
+    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).toHaveLength(1);
+    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 update only the content string within the content field, preserving metadata', async () => {
+    const originalMessage = createSampleMessageV2({
+      threadId: thread.id,
+      content: { metadata: { initial: true } },
+    });
+    await store.saveMessages({ messages: [originalMessage], format: 'v2' });
+
+    const newContentString = 'This is the new content string';
+    await store.updateMessages({
+      messages: [{ id: originalMessage.id, content: { content: newContentString } as any }],
+    });
+
+    const fromDb = await store.getMessages({ threadId: thread.id, format: 'v2' });
+    expect(fromDb[0].content.content).toBe(newContentString);
+    expect(fromDb[0].content.metadata).toEqual({ initial: true });
+  });
+
+  it('should deep merge metadata, not overwrite it', async () => {
+    const originalMessage = createSampleMessageV2({
+      threadId: thread.id,
+      content: { metadata: { initial: true }, content: 'old content' },
+    });
+    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.content).toBe('old content');
+    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' });
+    const msg2 = createSampleMessageV2({ threadId: thread.id, content: { content: 'original' } });
+    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 });
+    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 });
+    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);
+  });
+
+  it('should not fail when trying to update a non-existent message', async () => {
+    const originalMessage = createSampleMessageV2({ threadId: thread.id });
+    await store.saveMessages({ messages: [originalMessage], format: 'v2' });
+
+    await expect(
+      store.updateMessages({
+        messages: [{ id: randomUUID(), role: 'assistant' }],
+      }),
+    ).resolves.not.toThrow();
+
+    const fromDb = await store.getMessages({ threadId: thread.id, format: 'v2' });
+    expect(fromDb[0].role).toBe(originalMessage.role);
+  });
+});

package/src/storage/index.ts

@@ -1,7 +1,7 @@
 import { createClient } from '@libsql/client';
 import type { Client, InValue } from '@libsql/client';
 import { MessageList } from '@mastra/core/agent';
-import type { MastraMessageV2 } from '@mastra/core/agent';
+import type { MastraMessageContentV2, MastraMessageV2 } from '@mastra/core/agent';
 import type { MetricResult, TestInfo } from '@mastra/core/eval';
 import type { MastraMessageV1, StorageThreadType } from '@mastra/core/memory';
 import {
@@ -755,6 +755,112 @@ export class LibSQLStore extends MastraStorage {
     }
   }
 
+  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 placeholders = messageIds.map(() => '?').join(',');
+
+    const selectSql = `SELECT * FROM ${TABLE_MESSAGES} WHERE id IN (${placeholders})`;
+    const existingResult = await this.client.execute({ sql: selectSql, args: messageIds });
+    const existingMessages: MastraMessageV2[] = existingResult.rows.map(row => this.parseRow(row));
+
+    if (existingMessages.length === 0) {
+      return [];
+    }
+
+    const batchStatements = [];
+    const threadIdsToUpdate = new Set<string>();
+    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 = [];
+      const args: InValue[] = [];
+      const updatableFields = { ...fieldsToUpdate };
+
+      // Special handling for the 'content' field to merge instead of overwrite
+      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(`${parseSqlIdentifier('content', 'column name')} = ?`);
+        args.push(JSON.stringify(newContent));
+        delete updatableFields.content;
+      }
+
+      for (const key in updatableFields) {
+        if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+          const dbKey = columnMapping[key] || key;
+          setClauses.push(`${parseSqlIdentifier(dbKey, 'column name')} = ?`);
+          let value = updatableFields[key as keyof typeof updatableFields];
+
+          if (typeof value === 'object' && value !== null) {
+            value = JSON.stringify(value);
+          }
+          args.push(value as InValue);
+        }
+      }
+
+      if (setClauses.length === 0) continue;
+
+      args.push(id);
+
+      const sql = `UPDATE ${TABLE_MESSAGES} SET ${setClauses.join(', ')} WHERE id = ?`;
+      batchStatements.push({ sql, args });
+    }
+
+    if (batchStatements.length === 0) {
+      return existingMessages;
+    }
+
+    const now = new Date().toISOString();
+    for (const threadId of threadIdsToUpdate) {
+      if (threadId) {
+        batchStatements.push({
+          sql: `UPDATE ${TABLE_THREADS} SET updatedAt = ? WHERE id = ?`,
+          args: [now, threadId],
+        });
+      }
+    }
+
+    await this.client.batch(batchStatements, 'write');
+
+    const updatedResult = await this.client.execute({ sql: selectSql, args: messageIds });
+    return updatedResult.rows.map(row => this.parseRow(row));
+  }
+
   private transformEvalRow(row: Record<string, any>): EvalRow {
     const resultValue = JSON.parse(row.result as string);
     const testInfoValue = row.test_info ? JSON.parse(row.test_info as string) : undefined;