@mastra/mongodb 0.0.0-vnextAgentNetwork-20250602084555 → 0.0.0-workflow-deno-20250616115451

package/.turbo/turbo-build.log

@@ -0,0 +1,23 @@
+
+> @mastra/mongodb@0.11.0-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.5.0
+TSC Build start
+TSC ⚡️ Build success in 9462ms
+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 11575ms
+CLI Cleaning output folder
+ESM Build start
+CJS Build start
+ESM dist/index.js 33.93 KB
+ESM ⚡️ Build success in 1213ms
+CJS dist/index.cjs 34.07 KB
+CJS ⚡️ Build success in 1213ms

package/CHANGELOG.md

@@ -1,11 +1,157 @@
 # @mastra/mongodb
 
-## 0.0.0-vnextAgentNetwork-20250602084555
+## 0.0.0-workflow-deno-20250616115451
+
+### Minor Changes
+
+- 704d1ca: Thread Timestamp Auto-Update Enhancement
+  Added automatic thread updatedAt timestamp updates when messages are saved across all storage providers
+  Enhanced user experience: Threads now accurately reflect their latest activity with automatic timestamp updates when new messages are added
+  Universal implementation: Consistent behavior across all 7 storage backends (ClickHouse, Cloudflare D1, DynamoDB, MongoDB, PostgreSQL, Upstash, LibSQL)
+  Performance optimized: Updates execute in parallel with message saving operations for minimal performance impact
+  Backwards compatible: No breaking changes - existing code continues to work unchanged
+  Improved conversation ordering: Chat interfaces can now properly sort threads by actual last activity
+  This enhancement resolves the issue where active conversations appeared stale due to outdated thread timestamps, providing better conversation management and user experience in chat applications.
+
+### Patch Changes
+
+- 63f6b7d: dependencies updates:
+  - Updated dependency [`cloudflare@^4.3.0` ↗︎](https://www.npmjs.com/package/cloudflare/v/4.3.0) (from `^4.1.0`, in `dependencies`)
+  - Updated dependency [`mongodb@^6.17.0` ↗︎](https://www.npmjs.com/package/mongodb/v/6.17.0) (from `^6.15.0`, in `dependencies`)
+- Updated dependencies [63f6b7d]
+- Updated dependencies [ee9af57]
+- Updated dependencies [36f1c36]
+- Updated dependencies [10d352e]
+- Updated dependencies [3ca9a67]
+- Updated dependencies [53d3c37]
+- Updated dependencies [577ce3a]
+- Updated dependencies [9260b3a]
+  - @mastra/core@0.0.0-workflow-deno-20250616115451
+
+## 0.11.0-alpha.1
+
+### Minor Changes
+
+- 704d1ca: Thread Timestamp Auto-Update Enhancement
+  Added automatic thread updatedAt timestamp updates when messages are saved across all storage providers
+  Enhanced user experience: Threads now accurately reflect their latest activity with automatic timestamp updates when new messages are added
+  Universal implementation: Consistent behavior across all 7 storage backends (ClickHouse, Cloudflare D1, DynamoDB, MongoDB, PostgreSQL, Upstash, LibSQL)
+  Performance optimized: Updates execute in parallel with message saving operations for minimal performance impact
+  Backwards compatible: No breaking changes - existing code continues to work unchanged
+  Improved conversation ordering: Chat interfaces can now properly sort threads by actual last activity
+  This enhancement resolves the issue where active conversations appeared stale due to outdated thread timestamps, providing better conversation management and user experience in chat applications.
+
+## 0.10.4-alpha.0
+
+### Patch Changes
+
+- 63f6b7d: dependencies updates:
+  - Updated dependency [`cloudflare@^4.3.0` ↗︎](https://www.npmjs.com/package/cloudflare/v/4.3.0) (from `^4.1.0`, in `dependencies`)
+  - Updated dependency [`mongodb@^6.17.0` ↗︎](https://www.npmjs.com/package/mongodb/v/6.17.0) (from `^6.15.0`, in `dependencies`)
+- Updated dependencies [63f6b7d]
+- Updated dependencies [36f1c36]
+- Updated dependencies [10d352e]
+- Updated dependencies [53d3c37]
+  - @mastra/core@0.10.6-alpha.0
+
+## 0.10.3
+
+### Patch Changes
+
+- dffb67b: updated stores to add alter table and change tests
+- 925ab94: added paginated functions to base class and added boilerplate and updated imports
+- e030ea3: Added missing format compatibility to MongoDB getMessages() method
+- 66f4424: Update peerdeps
+- Updated dependencies [d1ed912]
+- Updated dependencies [f6fd25f]
+- Updated dependencies [dffb67b]
+- Updated dependencies [f1f1f1b]
+- Updated dependencies [925ab94]
+- Updated dependencies [f9816ae]
+- Updated dependencies [82090c1]
+- Updated dependencies [1b443fd]
+- Updated dependencies [ce97900]
+- Updated dependencies [f1309d3]
+- Updated dependencies [14a2566]
+- Updated dependencies [f7f8293]
+- Updated dependencies [48eddb9]
+  - @mastra/core@0.10.4
+
+## 0.10.3-alpha.2
+
+### Patch Changes
+
+- 66f4424: Update peerdeps
+
+## 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
+
+- c5bf1ce: Add backwards compat code for new MessageList in storage
+- f0d559f: Fix peerdeps for alpha channel
+- Updated dependencies [ee77e78]
+- Updated dependencies [592a2db]
+- Updated dependencies [e5dc18d]
+- Updated dependencies [ab5adbe]
+- Updated dependencies [1e8bb40]
+- Updated dependencies [1b5fc55]
+- Updated dependencies [195c428]
+- Updated dependencies [f73e11b]
+- Updated dependencies [37643b8]
+- Updated dependencies [99fd6cf]
+- Updated dependencies [c5bf1ce]
+- Updated dependencies [add596e]
+- Updated dependencies [8dc94d8]
+- Updated dependencies [ecebbeb]
+- Updated dependencies [79d5145]
+- Updated dependencies [12b7002]
+- Updated dependencies [2901125]
+  - @mastra/core@0.10.2
+
+## 0.10.2-alpha.1
+
+### Patch Changes
+
+- c5bf1ce: Add backwards compat code for new MessageList in storage
+- Updated dependencies [c5bf1ce]
+- Updated dependencies [12b7002]
+  - @mastra/core@0.10.2-alpha.4
+
+## 0.10.2-alpha.0
+
+### Patch Changes
+
+- f0d559f: Fix peerdeps for alpha channel
+- Updated dependencies [1e8bb40]
+  - @mastra/core@0.10.2-alpha.2
+
+## 0.10.1
 
 ### Patch Changes
 
 - 4a8cd1c: MongoDBStore option support
 - fcc915f: Support MongoDB database as store
+- Updated dependencies [d70b807]
 - Updated dependencies [6d16390]
 - Updated dependencies [1e4a421]
 - Updated dependencies [200d0da]
@@ -14,7 +160,21 @@
 - Updated dependencies [38aee50]
 - Updated dependencies [5c41100]
 - Updated dependencies [d6a759b]
-  - @mastra/core@0.0.0-vnextAgentNetwork-20250602084555
+- Updated dependencies [6015bdf]
+  - @mastra/core@0.10.1
+
+## 0.10.1-alpha.1
+
+### Patch Changes
+
+- 4a8cd1c: MongoDBStore option support
+- Updated dependencies [200d0da]
+- Updated dependencies [bf5f17b]
+- Updated dependencies [5343f93]
+- Updated dependencies [38aee50]
+- Updated dependencies [5c41100]
+- Updated dependencies [d6a759b]
+  - @mastra/core@0.10.1-alpha.1
 
 ## 0.10.1-alpha.0
 

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

@@ -5,16 +5,21 @@ import type { DeleteVectorParams } from '@mastra/core/vector';
 import type { DescribeIndexParams } from '@mastra/core/vector';
 import type { EvalRow } from '@mastra/core/storage';
 import type { IndexStats } from '@mastra/core/vector';
+import type { MastraMessageV1 } from '@mastra/core/memory';
+import type { MastraMessageV2 } from '@mastra/core/memory';
 import { MastraStorage } from '@mastra/core/storage';
 import { MastraVector } from '@mastra/core/vector';
-import type { MessageType } from '@mastra/core/memory';
 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';
@@ -70,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>;
@@ -102,10 +118,20 @@ declare class MongoDBStore extends MastraStorage {
     deleteThread({ threadId }: {
         threadId: string;
     }): Promise<void>;
-    getMessages<T = unknown>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T[]>;
-    saveMessages({ messages }: {
-        messages: MessageType[];
-    }): Promise<MessageType[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    saveMessages(args: {
+        messages: MastraMessageV1[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
     getTraces({ name, scope, page, perPage, attributes, filters, }?: {
         name?: string;
         scope?: string;
@@ -147,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

@@ -5,16 +5,21 @@ import type { DeleteVectorParams } from '@mastra/core/vector';
 import type { DescribeIndexParams } from '@mastra/core/vector';
 import type { EvalRow } from '@mastra/core/storage';
 import type { IndexStats } from '@mastra/core/vector';
+import type { MastraMessageV1 } from '@mastra/core/memory';
+import type { MastraMessageV2 } from '@mastra/core/memory';
 import { MastraStorage } from '@mastra/core/storage';
 import { MastraVector } from '@mastra/core/vector';
-import type { MessageType } from '@mastra/core/memory';
 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';
@@ -70,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>;
@@ -102,10 +118,20 @@ declare class MongoDBStore extends MastraStorage {
     deleteThread({ threadId }: {
         threadId: string;
     }): Promise<void>;
-    getMessages<T = unknown>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T[]>;
-    saveMessages({ messages }: {
-        messages: MessageType[];
-    }): Promise<MessageType[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    saveMessages(args: {
+        messages: MastraMessageV1[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
     getTraces({ name, scope, page, perPage, attributes, filters, }?: {
         name?: string;
         scope?: string;
@@ -147,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

@@ -4,6 +4,7 @@ var vector = require('@mastra/core/vector');
 var mongodb = require('mongodb');
 var uuid = require('uuid');
 var filter = require('@mastra/core/vector/filter');
+var agent = require('@mastra/core/agent');
 var storage = require('@mastra/core/storage');
 
 // src/vector/index.ts
@@ -446,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);
@@ -583,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 || [];
@@ -622,13 +635,18 @@ 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;
     }
   }
-  async saveMessages({ messages }) {
+  async saveMessages({
+    messages,
+    format
+  }) {
     if (!messages.length) {
       return messages;
     }
@@ -651,8 +669,14 @@ var MongoDBStore = class extends storage.MastraStorage {
         };
       });
       const collection = await this.getCollection(storage.TABLE_MESSAGES);
-      await collection.insertMany(messagesToInsert);
-      return messages;
+      const threadsCollection = await this.getCollection(storage.TABLE_THREADS);
+      await Promise.all([
+        collection.insertMany(messagesToInsert),
+        threadsCollection.updateOne({ id: threadId }, { $set: { updatedAt: /* @__PURE__ */ new Date() } })
+      ]);
+      const list = new agent.MessageList().add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
       this.logger.error("Failed to save messages in database: " + error?.message);
       throw error;
@@ -892,7 +916,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) {
@@ -917,6 +942,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

@@ -2,6 +2,7 @@ import { MastraVector } from '@mastra/core/vector';
 import { MongoClient } from 'mongodb';
 import { v4 } from 'uuid';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import { MessageList } from '@mastra/core/agent';
 import { MastraStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_TRACES, TABLE_WORKFLOW_SNAPSHOT, TABLE_EVALS } from '@mastra/core/storage';
 
 // src/vector/index.ts
@@ -444,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);
@@ -581,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 || [];
@@ -620,13 +633,18 @@ 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;
     }
   }
-  async saveMessages({ messages }) {
+  async saveMessages({
+    messages,
+    format
+  }) {
     if (!messages.length) {
       return messages;
     }
@@ -649,8 +667,14 @@ var MongoDBStore = class extends MastraStorage {
         };
       });
       const collection = await this.getCollection(TABLE_MESSAGES);
-      await collection.insertMany(messagesToInsert);
-      return messages;
+      const threadsCollection = await this.getCollection(TABLE_THREADS);
+      await Promise.all([
+        collection.insertMany(messagesToInsert),
+        threadsCollection.updateOne({ id: threadId }, { $set: { updatedAt: /* @__PURE__ */ new Date() } })
+      ]);
+      const list = new MessageList().add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
       this.logger.error("Failed to save messages in database: " + error?.message);
       throw error;
@@ -890,7 +914,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) {
@@ -915,6 +940,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.0.0-vnextAgentNetwork-20250602084555",
+  "version": "0.0.0-workflow-deno-20250616115451",
   "description": "MongoDB provider for Mastra - includes vector store capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -20,22 +20,23 @@
   },
   "dependencies": {
     "@types/mongodb": "^4.0.7",
-    "cloudflare": "^4.1.0",
-    "mongodb": "^6.15.0",
+    "cloudflare": "^4.3.0",
+    "mongodb": "^6.17.0",
     "uuid": "^11.1.0"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.52.5",
-    "@types/node": "^20.17.27",
-    "eslint": "^9.23.0",
-    "tsup": "^8.4.0",
-    "typescript": "^5.8.2",
-    "vitest": "^3.1.2",
-    "@internal/lint": "0.0.0-vnextAgentNetwork-20250602084555",
-    "@mastra/core": "0.0.0-vnextAgentNetwork-20250602084555"
+    "@microsoft/api-extractor": "^7.52.8",
+    "@types/node": "^20.19.0",
+    "eslint": "^9.28.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.3",
+    "@internal/lint": "0.0.0-workflow-deno-20250616115451",
+    "@internal/storage-test-utils": "0.0.0-workflow-deno-20250616115451",
+    "@mastra/core": "0.0.0-workflow-deno-20250616115451"
   },
   "peerDependencies": {
-    "@mastra/core": "^0.10.0"
+    "@mastra/core": ">=0.10.4-0 <0.11.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/storage/index.test.ts

@@ -1,7 +1,8 @@
 import { randomUUID } from 'crypto';
-import type { MessageType, 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): MessageType {
+  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,
     };
   }
 
@@ -88,10 +120,12 @@ class Test {
         },
         input: {},
       },
+      serializedStepGraph: [],
       activePaths: [],
       suspendedPaths: {},
       runId,
       timestamp: timestamp.getTime(),
+      status: options.status,
     } as WorkflowRunState;
     return { snapshot, runId, stepId };
   }
@@ -200,7 +234,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 });
@@ -235,6 +272,27 @@ describe('MongoDBStore', () => {
       expect(retrievedThread?.title).toBe('Updated Title');
       expect(retrievedThread?.metadata).toEqual({ key: 'newValue' });
     });
+
+    it('should update thread updatedAt when a message is saved to it', async () => {
+      const test = new Test(store).build();
+      await test.clearTables();
+
+      const thread = test.generateSampleThread();
+      await store.saveThread({ thread });
+
+      const initialThread = await store.getThreadById({ threadId: thread.id });
+      expect(initialThread).toBeDefined();
+      const originalUpdatedAt = initialThread!.updatedAt;
+
+      await new Promise(resolve => setTimeout(resolve, 10));
+
+      const message = test.generateSampleMessageV1({ threadId: thread.id });
+      await store.saveMessages({ messages: [message] });
+
+      const updatedThread = await store.getThreadById({ threadId: thread.id });
+      expect(updatedThread).toBeDefined();
+      expect(updatedThread!.updatedAt.getTime()).toBeGreaterThan(originalUpdatedAt.getTime());
+    });
   });
 
   describe('Message Operations', () => {
@@ -244,7 +302,10 @@ describe('MongoDBStore', () => {
       const thread = test.generateSampleThread();
       await store.saveThread({ thread });
 
-      const messages = [test.generateSampleMessage(thread.id), test.generateSampleMessage(thread.id)];
+      const messages = [
+        test.generateSampleMessageV1({ threadId: thread.id }),
+        { ...test.generateSampleMessageV1({ threadId: thread.id }), role: 'assistant' as const },
+      ];
 
       // Save messages
       const savedMessages = await store.saveMessages({ messages });
@@ -273,29 +334,129 @@ describe('MongoDBStore', () => {
 
       const messages = [
         {
-          ...test.generateSampleMessage(thread.id),
-          content: [{ type: 'text', text: 'First' }] as MessageType['content'],
+          ...test.generateSampleMessageV2({ threadId: thread.id, content: 'First' }),
         },
         {
-          ...test.generateSampleMessage(thread.id),
-          content: [{ type: 'text', text: 'Second' }] as MessageType['content'],
+          ...test.generateSampleMessageV2({ threadId: thread.id, content: 'Second' }),
         },
         {
-          ...test.generateSampleMessage(thread.id),
-          content: [{ type: 'text', text: 'Third' }] as MessageType['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', () => {
@@ -479,7 +640,9 @@ describe('MongoDBStore', () => {
             status: 'waiting',
           },
         ],
+        serializedStepGraph: [],
         runId: runId,
+        status: 'running',
         timestamp: Date.now(),
       };
 
@@ -768,6 +931,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,6 +1,15 @@
+import { MessageList } from '@mastra/core/agent';
 import type { MetricResult, TestInfo } from '@mastra/core/eval';
-import type { MessageType, StorageThreadType } from '@mastra/core/memory';
-import type { EvalRow, StorageGetMessagesArg, TABLE_NAMES, WorkflowRun } from '@mastra/core/storage';
+import type { MastraMessageV1, MastraMessageV2, StorageThreadType } from '@mastra/core/memory';
+import type {
+  EvalRow,
+  PaginationInfo,
+  StorageColumn,
+  StorageGetMessagesArg,
+  StorageGetTracesArg,
+  TABLE_NAMES,
+  WorkflowRun,
+} from '@mastra/core/storage';
 import {
   MastraStorage,
   TABLE_EVALS,
@@ -9,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';
@@ -73,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);
@@ -231,12 +255,20 @@ 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 || [];
-      let messages: MessageType[] = [];
-      let allMessages: MessageType[] = [];
+      let messages: MastraMessageV2[] = [];
+      let allMessages: MastraMessageV2[] = [];
       const collection = await this.getCollection(TABLE_MESSAGES);
       // Get all messages from the thread ordered by creation date descending
       allMessages = (await collection.find({ thread_id: threadId }).sort({ createdAt: -1 }).toArray()).map((row: any) =>
@@ -270,7 +302,7 @@ export class MongoDBStore extends MastraStorage {
         messages.push(
           ...Array.from(selectedIndexes)
             .map(i => allMessages[i])
-            .filter((m): m is MessageType => !!m),
+            .filter((m): m is MastraMessageV2 => !!m),
         );
       }
 
@@ -286,14 +318,23 @@ 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;
     }
   }
 
-  async saveMessages({ messages }: { messages: MessageType[] }): Promise<MessageType[]> {
+  async saveMessages(args: { messages: MastraMessageV1[]; format?: undefined | 'v1' }): Promise<MastraMessageV1[]>;
+  async saveMessages(args: { messages: MastraMessageV2[]; format: 'v2' }): Promise<MastraMessageV2[]>;
+  async saveMessages({
+    messages,
+    format,
+  }:
+    | { messages: MastraMessageV1[]; format?: undefined | 'v1' }
+    | { messages: MastraMessageV2[]; format: 'v2' }): Promise<MastraMessageV2[] | MastraMessageV1[]> {
     if (!messages.length) {
       return messages;
     }
@@ -303,6 +344,7 @@ export class MongoDBStore extends MastraStorage {
       this.logger.error('Thread ID is required to save messages');
       throw new Error('Thread ID is required');
     }
+
     try {
       // Prepare batch statements for all messages
       const messagesToInsert = messages.map(message => {
@@ -318,10 +360,18 @@ export class MongoDBStore extends MastraStorage {
         };
       });
 
-      // Execute all inserts in a single batch
+      // Execute message inserts and thread update in parallel for better performance
       const collection = await this.getCollection(TABLE_MESSAGES);
-      await collection.insertMany(messagesToInsert);
-      return messages;
+      const threadsCollection = await this.getCollection(TABLE_THREADS);
+
+      await Promise.all([
+        collection.insertMany(messagesToInsert),
+        threadsCollection.updateOne({ id: threadId }, { $set: { updatedAt: new Date() } }),
+      ]);
+
+      const list = new MessageList().add(messages, 'memory');
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
       this.logger.error('Failed to save messages in database: ' + (error as { message: string })?.message);
       throw error;
@@ -628,7 +678,7 @@ export class MongoDBStore extends MastraStorage {
     };
   }
 
-  private parseRow(row: any): MessageType {
+  private parseRow(row: any): MastraMessageV2 {
     let content = row.content;
     try {
       content = JSON.parse(row.content);
@@ -642,7 +692,8 @@ export class MongoDBStore extends MastraStorage {
       type: row.type,
       createdAt: new Date(row.createdAt as string),
       threadId: row.thread_id,
-    } as MessageType;
+      resourceId: row.resourceId,
+    } as MastraMessageV2;
   }
 
   private transformEvalRow(row: Record<string, any>): EvalRow {
@@ -669,6 +720,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();
   }