@mastra/mongodb 0.10.2 → 0.10.3-alpha.1

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/mongodb@0.10.2-alpha.1 build /home/runner/work/mastra/mastra/stores/mongodb
+> @mastra/mongodb@0.10.3-alpha.1 build /home/runner/work/mastra/mastra/stores/mongodb
 > 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.4.0
+CLI tsup v8.5.0
 TSC Build start
-TSC ⚡️ Build success in 7878ms
+TSC ⚡️ Build success in 8770ms
 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/mongodb/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/mongodb/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 12007ms
+DTS ⚡️ Build success in 11972ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 33.01 KB
-ESM ⚡️ Build success in 1201ms
-CJS dist/index.cjs 33.13 KB
-CJS ⚡️ Build success in 1192ms
+CJS dist/index.cjs 33.85 KB
+CJS ⚡️ Build success in 1239ms
+ESM dist/index.js 33.73 KB
+ESM ⚡️ Build success in 1239ms

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @mastra/mongodb
 
+## 0.10.3-alpha.1
+
+### Patch Changes
+
+- 925ab94: added paginated functions to base class and added boilerplate and updated imports
+- Updated dependencies [925ab94]
+  - @mastra/core@0.10.4-alpha.3
+
+## 0.10.3-alpha.0
+
+### Patch Changes
+
+- dffb67b: updated stores to add alter table and change tests
+- e030ea3: Added missing format compatibility to MongoDB getMessages() method
+- Updated dependencies [f6fd25f]
+- Updated dependencies [dffb67b]
+- Updated dependencies [f1309d3]
+- Updated dependencies [f7f8293]
+  - @mastra/core@0.10.4-alpha.1
+
 ## 0.10.2
 
 ### Patch Changes

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

@@ -11,11 +11,15 @@ import { MastraStorage } from '@mastra/core/storage';
 import { MastraVector } from '@mastra/core/vector';
 import type { MongoClientOptions } from 'mongodb';
 import type { OperatorSupport } from '@mastra/core/vector/filter';
+import type { PaginationInfo } from '@mastra/core/storage';
 import type { QueryResult } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
+import type { StorageColumn } from '@mastra/core/storage';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
+import type { StorageGetTracesArg } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
 import type { TABLE_NAMES } from '@mastra/core/storage';
+import type { Trace } from '@mastra/core/telemetry';
 import type { UpdateVectorParams } from '@mastra/core/vector';
 import type { UpsertVectorParams } from '@mastra/core/vector';
 import type { VectorFilter } from '@mastra/core/vector/filter';
@@ -71,6 +75,17 @@ declare class MongoDBStore extends MastraStorage {
     private getConnection;
     private getCollection;
     createTable(): Promise<void>;
+    /**
+     * No-op: This backend is schemaless and does not require schema changes.
+     * @param tableName Name of the table
+     * @param schema Schema of the table
+     * @param ifNotExists Array of column names to add if they don't exist
+     */
+    alterTable(_args: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;
@@ -103,7 +118,12 @@ declare class MongoDBStore extends MastraStorage {
     deleteThread({ threadId }: {
         threadId: string;
     }): Promise<void>;
-    getMessages<T = unknown>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
     saveMessages(args: {
         messages: MastraMessageV1[];
         format?: undefined | 'v1';
@@ -153,6 +173,19 @@ declare class MongoDBStore extends MastraStorage {
     private parseWorkflowRun;
     private parseRow;
     private transformEvalRow;
+    getTracesPaginated(_args: StorageGetTracesArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+    getThreadsByResourceIdPaginated(_args: {
+        resourceId: string;
+        page?: number;
+        perPage?: number;
+    }): Promise<PaginationInfo & {
+        threads: StorageThreadType[];
+    }>;
+    getMessagesPaginated(_args: StorageGetMessagesArg): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2[];
+    }>;
     close(): Promise<void>;
 }
 export { MongoDBStore }

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

@@ -11,11 +11,15 @@ import { MastraStorage } from '@mastra/core/storage';
 import { MastraVector } from '@mastra/core/vector';
 import type { MongoClientOptions } from 'mongodb';
 import type { OperatorSupport } from '@mastra/core/vector/filter';
+import type { PaginationInfo } from '@mastra/core/storage';
 import type { QueryResult } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
+import type { StorageColumn } from '@mastra/core/storage';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
+import type { StorageGetTracesArg } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
 import type { TABLE_NAMES } from '@mastra/core/storage';
+import type { Trace } from '@mastra/core/telemetry';
 import type { UpdateVectorParams } from '@mastra/core/vector';
 import type { UpsertVectorParams } from '@mastra/core/vector';
 import type { VectorFilter } from '@mastra/core/vector/filter';
@@ -71,6 +75,17 @@ declare class MongoDBStore extends MastraStorage {
     private getConnection;
     private getCollection;
     createTable(): Promise<void>;
+    /**
+     * No-op: This backend is schemaless and does not require schema changes.
+     * @param tableName Name of the table
+     * @param schema Schema of the table
+     * @param ifNotExists Array of column names to add if they don't exist
+     */
+    alterTable(_args: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;
@@ -103,7 +118,12 @@ declare class MongoDBStore extends MastraStorage {
     deleteThread({ threadId }: {
         threadId: string;
     }): Promise<void>;
-    getMessages<T = unknown>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
     saveMessages(args: {
         messages: MastraMessageV1[];
         format?: undefined | 'v1';
@@ -153,6 +173,19 @@ declare class MongoDBStore extends MastraStorage {
     private parseWorkflowRun;
     private parseRow;
     private transformEvalRow;
+    getTracesPaginated(_args: StorageGetTracesArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+    getThreadsByResourceIdPaginated(_args: {
+        resourceId: string;
+        page?: number;
+        perPage?: number;
+    }): Promise<PaginationInfo & {
+        threads: StorageThreadType[];
+    }>;
+    getMessagesPaginated(_args: StorageGetMessagesArg): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2[];
+    }>;
     close(): Promise<void>;
 }
 export { MongoDBStore }

package/dist/index.cjs

@@ -447,6 +447,14 @@ var MongoDBStore = class extends storage.MastraStorage {
   }
   async createTable() {
   }
+  /**
+   * No-op: This backend is schemaless and does not require schema changes.
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable(_args) {
+  }
   async clearTable({ tableName }) {
     try {
       const collection = await this.getCollection(tableName);
@@ -584,7 +592,11 @@ var MongoDBStore = class extends storage.MastraStorage {
       throw error;
     }
   }
-  async getMessages({ threadId, selectBy }) {
+  async getMessages({
+    threadId,
+    selectBy,
+    format
+  }) {
     try {
       const limit = typeof selectBy?.last === "number" ? selectBy.last : 40;
       const include = selectBy?.include || [];
@@ -623,7 +635,9 @@ var MongoDBStore = class extends storage.MastraStorage {
         }
       }
       messages.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-      return messages.slice(0, limit);
+      const list = new agent.MessageList().add(messages.slice(0, limit), "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
       this.logger.error("Error getting messages:", error);
       throw error;
@@ -898,7 +912,8 @@ var MongoDBStore = class extends storage.MastraStorage {
       role: row.role,
       type: row.type,
       createdAt: new Date(row.createdAt),
-      threadId: row.thread_id
+      threadId: row.thread_id,
+      resourceId: row.resourceId
     };
   }
   transformEvalRow(row) {
@@ -923,6 +938,15 @@ var MongoDBStore = class extends storage.MastraStorage {
       createdAt: row.created_at
     };
   }
+  async getTracesPaginated(_args) {
+    throw new Error("Method not implemented.");
+  }
+  async getThreadsByResourceIdPaginated(_args) {
+    throw new Error("Method not implemented.");
+  }
+  async getMessagesPaginated(_args) {
+    throw new Error("Method not implemented.");
+  }
   async close() {
     await this.#client.close();
   }

package/dist/index.js

@@ -445,6 +445,14 @@ var MongoDBStore = class extends MastraStorage {
   }
   async createTable() {
   }
+  /**
+   * No-op: This backend is schemaless and does not require schema changes.
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable(_args) {
+  }
   async clearTable({ tableName }) {
     try {
       const collection = await this.getCollection(tableName);
@@ -582,7 +590,11 @@ var MongoDBStore = class extends MastraStorage {
       throw error;
     }
   }
-  async getMessages({ threadId, selectBy }) {
+  async getMessages({
+    threadId,
+    selectBy,
+    format
+  }) {
     try {
       const limit = typeof selectBy?.last === "number" ? selectBy.last : 40;
       const include = selectBy?.include || [];
@@ -621,7 +633,9 @@ var MongoDBStore = class extends MastraStorage {
         }
       }
       messages.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-      return messages.slice(0, limit);
+      const list = new MessageList().add(messages.slice(0, limit), "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
       this.logger.error("Error getting messages:", error);
       throw error;
@@ -896,7 +910,8 @@ var MongoDBStore = class extends MastraStorage {
       role: row.role,
       type: row.type,
       createdAt: new Date(row.createdAt),
-      threadId: row.thread_id
+      threadId: row.thread_id,
+      resourceId: row.resourceId
     };
   }
   transformEvalRow(row) {
@@ -921,6 +936,15 @@ var MongoDBStore = class extends MastraStorage {
       createdAt: row.created_at
     };
   }
+  async getTracesPaginated(_args) {
+    throw new Error("Method not implemented.");
+  }
+  async getThreadsByResourceIdPaginated(_args) {
+    throw new Error("Method not implemented.");
+  }
+  async getMessagesPaginated(_args) {
+    throw new Error("Method not implemented.");
+  }
   async close() {
     await this.#client.close();
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mongodb",
-  "version": "0.10.2",
+  "version": "0.10.3-alpha.1",
   "description": "MongoDB provider for Mastra - includes vector store capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -25,14 +25,15 @@
     "uuid": "^11.1.0"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.52.5",
-    "@types/node": "^20.17.27",
-    "eslint": "^9.23.0",
-    "tsup": "^8.4.0",
+    "@microsoft/api-extractor": "^7.52.8",
+    "@types/node": "^20.17.57",
+    "eslint": "^9.28.0",
+    "tsup": "^8.5.0",
     "typescript": "^5.8.2",
-    "vitest": "^3.1.2",
-    "@internal/lint": "0.0.8",
-    "@mastra/core": "0.10.2"
+    "vitest": "^3.2.2",
+    "@internal/lint": "0.0.10",
+    "@mastra/core": "0.10.4-alpha.3",
+    "@internal/storage-test-utils": "0.0.6"
   },
   "peerDependencies": {
     "@mastra/core": "^0.10.2-alpha.0"

package/src/storage/index.test.ts

@@ -1,7 +1,8 @@
 import { randomUUID } from 'crypto';
-import type { MastraMessageV1, MetricResult, WorkflowRunState } from '@mastra/core';
+import type { MastraMessageV1, MastraMessageV2, MetricResult, WorkflowRunState } from '@mastra/core';
+import type { TABLE_NAMES } from '@mastra/core/storage';
 import { TABLE_EVALS, TABLE_MESSAGES, TABLE_THREADS, TABLE_WORKFLOW_SNAPSHOT } from '@mastra/core/storage';
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import type { MongoDBConfig } from './index';
 import { MongoDBStore } from './index';
 
@@ -40,15 +41,46 @@ class Test {
     };
   }
 
-  generateSampleMessage(threadId: string): MastraMessageV1 {
+  generateSampleMessageV1({
+    threadId,
+    resourceId = randomUUID(),
+    content = 'Hello',
+  }: {
+    threadId: string;
+    resourceId?: string;
+    content?: string;
+  }): MastraMessageV1 {
     return {
       id: `msg-${randomUUID()}`,
       role: 'user',
       type: 'text',
       threadId,
-      content: [{ type: 'text', text: 'Hello' }],
+      content: [{ type: 'text', text: content }],
       createdAt: new Date(),
-      resourceId: randomUUID(),
+      resourceId,
+    };
+  }
+
+  generateSampleMessageV2({
+    threadId,
+    resourceId = randomUUID(),
+    content = 'Hello',
+  }: {
+    threadId: string;
+    resourceId?: string;
+    content?: string;
+  }): MastraMessageV2 {
+    return {
+      id: `msg-${randomUUID()}`,
+      role: 'user',
+      type: 'text',
+      threadId,
+      content: {
+        format: 2,
+        parts: [{ type: 'text', text: content }],
+      },
+      createdAt: new Date(),
+      resourceId,
     };
   }
 
@@ -201,7 +233,10 @@ describe('MongoDBStore', () => {
       await store.saveThread({ thread });
 
       // Add some messages
-      const messages = [test.generateSampleMessage(thread.id), test.generateSampleMessage(thread.id)];
+      const messages = [
+        test.generateSampleMessageV1({ threadId: thread.id }),
+        test.generateSampleMessageV1({ threadId: thread.id }),
+      ];
       await store.saveMessages({ messages });
 
       await store.deleteThread({ threadId: thread.id });
@@ -246,8 +281,8 @@ describe('MongoDBStore', () => {
       await store.saveThread({ thread });
 
       const messages = [
-        test.generateSampleMessage(thread.id),
-        { ...test.generateSampleMessage(thread.id), role: 'assistant' as const },
+        test.generateSampleMessageV1({ threadId: thread.id }),
+        { ...test.generateSampleMessageV1({ threadId: thread.id }), role: 'assistant' as const },
       ];
 
       // Save messages
@@ -277,29 +312,129 @@ describe('MongoDBStore', () => {
 
       const messages = [
         {
-          ...test.generateSampleMessage(thread.id),
-          content: [{ type: 'text', text: 'First' }] as MastraMessageV1['content'],
+          ...test.generateSampleMessageV2({ threadId: thread.id, content: 'First' }),
         },
         {
-          ...test.generateSampleMessage(thread.id),
-          content: [{ type: 'text', text: 'Second' }] as MastraMessageV1['content'],
+          ...test.generateSampleMessageV2({ threadId: thread.id, content: 'Second' }),
         },
         {
-          ...test.generateSampleMessage(thread.id),
-          content: [{ type: 'text', text: 'Third' }] as MastraMessageV1['content'],
+          ...test.generateSampleMessageV2({ threadId: thread.id, content: 'Third' }),
         },
       ];
 
-      await store.saveMessages({ messages });
+      await store.saveMessages({ messages, format: 'v2' });
 
-      const retrievedMessages = await store.getMessages({ threadId: thread.id });
+      const retrievedMessages = await store.getMessages({ threadId: thread.id, format: 'v2' });
       expect(retrievedMessages).toHaveLength(3);
 
       // Verify order is maintained
       retrievedMessages.forEach((msg, idx) => {
-        expect(((msg as any).content[0] as any).text).toBe((messages[idx]!.content[0] as any).text);
+        expect((msg as any).content.parts).toEqual(messages[idx]!.content.parts);
       });
     });
+
+    // it('should retrieve messages w/ next/prev messages by message id + resource id', async () => {
+    //   const test = new Test(store).build();
+    //   const messages: MastraMessageV2[] = [
+    //     test.generateSampleMessageV2({ threadId: 'thread-one', content: 'First', resourceId: 'cross-thread-resource' }),
+    //     test.generateSampleMessageV2({
+    //       threadId: 'thread-one',
+    //       content: 'Second',
+    //       resourceId: 'cross-thread-resource',
+    //     }),
+    //     test.generateSampleMessageV2({ threadId: 'thread-one', content: 'Third', resourceId: 'cross-thread-resource' }),
+
+    //     test.generateSampleMessageV2({
+    //       threadId: 'thread-two',
+    //       content: 'Fourth',
+    //       resourceId: 'cross-thread-resource',
+    //     }),
+    //     test.generateSampleMessageV2({ threadId: 'thread-two', content: 'Fifth', resourceId: 'cross-thread-resource' }),
+    //     test.generateSampleMessageV2({ threadId: 'thread-two', content: 'Sixth', resourceId: 'cross-thread-resource' }),
+
+    //     test.generateSampleMessageV2({ threadId: 'thread-three', content: 'Seventh', resourceId: 'other-resource' }),
+    //     test.generateSampleMessageV2({ threadId: 'thread-three', content: 'Eighth', resourceId: 'other-resource' }),
+    //   ];
+
+    //   await store.saveMessages({ messages: messages, format: 'v2' });
+
+    //   const retrievedMessages: MastraMessageV2[] = await store.getMessages({ threadId: 'thread-one', format: 'v2' });
+    //   expect(retrievedMessages).toHaveLength(3);
+    //   expect(retrievedMessages.map(m => (m.content.parts[0] as any).text)).toEqual(['First', 'Second', 'Third']);
+
+    //   const retrievedMessages2: MastraMessageV2[] = await store.getMessages({ threadId: 'thread-two', format: 'v2' });
+    //   expect(retrievedMessages2).toHaveLength(3);
+    //   expect(retrievedMessages2.map(m => (m.content.parts[0] as any).text)).toEqual(['Fourth', 'Fifth', 'Sixth']);
+
+    //   const retrievedMessages3: MastraMessageV2[] = await store.getMessages({ threadId: 'thread-three', format: 'v2' });
+    //   expect(retrievedMessages3).toHaveLength(2);
+    //   expect(retrievedMessages3.map(m => (m.content.parts[0] as any).text)).toEqual(['Seventh', 'Eighth']);
+
+    //   const crossThreadMessages: MastraMessageV2[] = await store.getMessages({
+    //     threadId: 'thread-doesnt-exist',
+    //     resourceId: 'cross-thread-resource',
+    //     format: 'v2',
+    //     selectBy: {
+    //       last: 0,
+    //       include: [
+    //         {
+    //           id: messages[1].id,
+    //           withNextMessages: 2,
+    //           withPreviousMessages: 2,
+    //         },
+    //         {
+    //           id: messages[4].id,
+    //           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',
+    //     resourceId: 'cross-thread-resource',
+    //     format: 'v2',
+    //     selectBy: {
+    //       last: 0,
+    //       include: [
+    //         {
+    //           id: messages[4].id,
+    //           withPreviousMessages: 1,
+    //           withNextMessages: 30,
+    //         },
+    //       ],
+    //     },
+    //   });
+
+    //   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',
+    //     resourceId: 'cross-thread-resource',
+    //     format: 'v2',
+    //     selectBy: {
+    //       last: 0,
+    //       include: [
+    //         {
+    //           id: messages[1].id,
+    //           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', () => {
@@ -773,6 +908,89 @@ describe('MongoDBStore', () => {
     });
   });
 
+  describe('alterTable (no-op/schemaless)', () => {
+    const TEST_TABLE = 'test_alter_table'; // Use "table" or "collection" as appropriate
+    beforeEach(async () => {
+      await store.clearTable({ tableName: TEST_TABLE as TABLE_NAMES });
+    });
+
+    afterEach(async () => {
+      await store.clearTable({ tableName: TEST_TABLE as TABLE_NAMES });
+    });
+
+    it('allows inserting records with new fields without alterTable', async () => {
+      await store.insert({
+        tableName: TEST_TABLE as TABLE_NAMES,
+        record: { id: '1', name: 'Alice' },
+      });
+      await store.insert({
+        tableName: TEST_TABLE as TABLE_NAMES,
+        record: { id: '2', name: 'Bob', newField: 123 },
+      });
+
+      const row = await store.load<{ id: string; name: string; newField?: number }[]>({
+        tableName: TEST_TABLE as TABLE_NAMES,
+        keys: { id: '2' },
+      });
+      expect(row?.[0]?.newField).toBe(123);
+    });
+
+    it('does not throw when calling alterTable (no-op)', async () => {
+      await expect(
+        store.alterTable({
+          tableName: TEST_TABLE as TABLE_NAMES,
+          schema: {
+            id: { type: 'text', primaryKey: true, nullable: false },
+            name: { type: 'text', nullable: true },
+            extra: { type: 'integer', nullable: true },
+          },
+          ifNotExists: ['extra'],
+        }),
+      ).resolves.not.toThrow();
+    });
+
+    it('can add multiple new fields at write time', async () => {
+      await store.insert({
+        tableName: TEST_TABLE as TABLE_NAMES,
+        record: { id: '3', name: 'Charlie', age: 30, city: 'Paris' },
+      });
+      const row = await store.load<{ id: string; name: string; age?: number; city?: string }[]>({
+        tableName: TEST_TABLE as TABLE_NAMES,
+        keys: { id: '3' },
+      });
+      expect(row?.[0]?.age).toBe(30);
+      expect(row?.[0]?.city).toBe('Paris');
+    });
+
+    it('can retrieve all fields, including dynamically added ones', async () => {
+      await store.insert({
+        tableName: TEST_TABLE as TABLE_NAMES,
+        record: { id: '4', name: 'Dana', hobby: 'skiing' },
+      });
+      const row = await store.load<{ id: string; name: string; hobby?: string }[]>({
+        tableName: TEST_TABLE as TABLE_NAMES,
+        keys: { id: '4' },
+      });
+      expect(row?.[0]?.hobby).toBe('skiing');
+    });
+
+    it('does not restrict or error on arbitrary new fields', async () => {
+      await expect(
+        store.insert({
+          tableName: TEST_TABLE as TABLE_NAMES,
+          record: { id: '5', weirdField: { nested: true }, another: [1, 2, 3] },
+        }),
+      ).resolves.not.toThrow();
+
+      const row = await store.load<{ id: string; weirdField?: any; another?: any }[]>({
+        tableName: TEST_TABLE as TABLE_NAMES,
+        keys: { id: '5' },
+      });
+      expect(row?.[0]?.weirdField).toEqual({ nested: true });
+      expect(row?.[0]?.another).toEqual([1, 2, 3]);
+    });
+  });
+
   afterAll(async () => {
     try {
       await store.close();

package/src/storage/index.ts

@@ -1,7 +1,15 @@
 import { MessageList } from '@mastra/core/agent';
 import type { MetricResult, TestInfo } from '@mastra/core/eval';
 import type { MastraMessageV1, MastraMessageV2, StorageThreadType } from '@mastra/core/memory';
-import type { EvalRow, StorageGetMessagesArg, TABLE_NAMES, WorkflowRun } from '@mastra/core/storage';
+import type {
+  EvalRow,
+  PaginationInfo,
+  StorageColumn,
+  StorageGetMessagesArg,
+  StorageGetTracesArg,
+  TABLE_NAMES,
+  WorkflowRun,
+} from '@mastra/core/storage';
 import {
   MastraStorage,
   TABLE_EVALS,
@@ -10,6 +18,7 @@ import {
   TABLE_TRACES,
   TABLE_WORKFLOW_SNAPSHOT,
 } from '@mastra/core/storage';
+import type { Trace } from '@mastra/core/telemetry';
 import type { WorkflowRunState } from '@mastra/core/workflows';
 import type { Db, MongoClientOptions } from 'mongodb';
 import { MongoClient } from 'mongodb';
@@ -74,6 +83,20 @@ export class MongoDBStore extends MastraStorage {
     // Nothing to do here, MongoDB is schemaless
   }
 
+  /**
+   * No-op: This backend is schemaless and does not require schema changes.
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable(_args: {
+    tableName: TABLE_NAMES;
+    schema: Record<string, StorageColumn>;
+    ifNotExists: string[];
+  }): Promise<void> {
+    // Nothing to do here, MongoDB is schemaless
+  }
+
   async clearTable({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
     try {
       const collection = await this.getCollection(tableName);
@@ -232,7 +255,15 @@ export class MongoDBStore extends MastraStorage {
     }
   }
 
-  async getMessages<T = unknown>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T[]> {
+  public async getMessages(args: StorageGetMessagesArg & { format?: 'v1' }): Promise<MastraMessageV1[]>;
+  public async getMessages(args: StorageGetMessagesArg & { format: 'v2' }): Promise<MastraMessageV2[]>;
+  public async getMessages({
+    threadId,
+    selectBy,
+    format,
+  }: StorageGetMessagesArg & {
+    format?: 'v1' | 'v2';
+  }): Promise<MastraMessageV1[] | MastraMessageV2[]> {
     try {
       const limit = typeof selectBy?.last === 'number' ? selectBy.last : 40;
       const include = selectBy?.include || [];
@@ -287,7 +318,9 @@ export class MongoDBStore extends MastraStorage {
       // Sort all messages by creation date ascending
       messages.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
 
-      return messages.slice(0, limit) as T[];
+      const list = new MessageList().add(messages.slice(0, limit), 'memory');
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
       this.logger.error('Error getting messages:', error as Error);
       throw error;
@@ -652,6 +685,7 @@ export class MongoDBStore extends MastraStorage {
       type: row.type,
       createdAt: new Date(row.createdAt as string),
       threadId: row.thread_id,
+      resourceId: row.resourceId,
     } as MastraMessageV2;
   }
 
@@ -679,6 +713,24 @@ export class MongoDBStore extends MastraStorage {
     };
   }
 
+  async getTracesPaginated(_args: StorageGetTracesArg): Promise<PaginationInfo & { traces: Trace[] }> {
+    throw new Error('Method not implemented.');
+  }
+
+  async getThreadsByResourceIdPaginated(_args: {
+    resourceId: string;
+    page?: number;
+    perPage?: number;
+  }): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
+    throw new Error('Method not implemented.');
+  }
+
+  async getMessagesPaginated(
+    _args: StorageGetMessagesArg,
+  ): Promise<PaginationInfo & { messages: MastraMessageV1[] | MastraMessageV2[] }> {
+    throw new Error('Method not implemented.');
+  }
+
   async close(): Promise<void> {
     await this.#client.close();
   }