@mastra/mongodb 0.11.1-alpha.1 → 0.11.1-alpha.2

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/mongodb@0.11.1-alpha.1 build /home/runner/work/mastra/mastra/stores/mongodb
+> @mastra/mongodb@0.11.1-alpha.2 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 8941ms
+TSC ⚡️ Build success in 10005ms
 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 11876ms
+DTS ⚡️ Build success in 11238ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 42.74 KB
-CJS ⚡️ Build success in 976ms
-ESM dist/index.js 41.92 KB
-ESM ⚡️ Build success in 976ms
+ESM dist/index.js 42.52 KB
+ESM ⚡️ Build success in 1306ms
+CJS dist/index.cjs 43.36 KB
+CJS ⚡️ Build success in 1315ms

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @mastra/mongodb
 
+## 0.11.1-alpha.2
+
+### Patch Changes
+
+- a2eceb2: fix: mongo storage trace query
+- 0fb9d64: [MASTRA-4018] Update saveMessages in storage adapters to upsert messages
+- 870f156: Parse eval result
+- 144eb0b: [MASTRA-3669] Metadata Filter Types
+- Updated dependencies [15e9d26]
+- Updated dependencies [07d6d88]
+- Updated dependencies [5d74aab]
+- Updated dependencies [144eb0b]
+  - @mastra/core@0.10.7-alpha.2
+
 ## 0.11.1-alpha.1
 
 ### Patch Changes

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

@@ -1,10 +1,12 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { BlacklistedRootOperators } from '@mastra/core/vector/filter';
 import type { CreateIndexParams } from '@mastra/core/vector';
 import type { DeleteIndexParams } from '@mastra/core/vector';
 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 { LogicalOperatorValueMap } from '@mastra/core/vector/filter';
 import type { MastraMessageContentV2 } from '@mastra/core/agent';
 import type { MastraMessageV1 } from '@mastra/core/memory';
 import type { MastraMessageV2 } from '@mastra/core/memory';
@@ -12,6 +14,7 @@ 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 { OperatorValueMap } 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';
@@ -23,6 +26,7 @@ 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 { VectorFieldValue } from '@mastra/core/vector/filter';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 import type { WorkflowRun } from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
@@ -35,6 +39,8 @@ declare const MONGODB_PROMPT = "When querying MongoDB Vector, you can ONLY use t
 export { MONGODB_PROMPT }
 export { MONGODB_PROMPT as MONGODB_PROMPT_alias_1 }
 
+declare type MongoDBBlacklisted = BlacklistedRootOperators | '$size';
+
 declare interface MongoDBConfig {
     url: string;
     dbName: string;
@@ -48,9 +54,9 @@ export { MongoDBConfig as MongoDBConfig_alias_1 }
  * Maintains MongoDB-compatible syntax while ensuring proper validation
  * and normalization of values.
  */
-export declare class MongoDBFilterTranslator extends BaseFilterTranslator {
+export declare class MongoDBFilterTranslator extends BaseFilterTranslator<MongoDBVectorFilter> {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: VectorFilter): any;
+    translate(filter?: MongoDBVectorFilter): any;
     private translateNode;
     private translateOperatorValue;
     isEmpty(filter: any): boolean;
@@ -64,11 +70,13 @@ declare interface MongoDBIndexReadyParams {
 export { MongoDBIndexReadyParams }
 export { MongoDBIndexReadyParams as MongoDBIndexReadyParams_alias_1 }
 
-declare interface MongoDBQueryVectorParams extends QueryVectorParams {
-    documentFilter?: VectorFilter;
+declare type MongoDBOperatorValueMap = Omit<OperatorValueMap, '$options'> & {
+    $size: number;
+};
+
+declare interface MongoDBQueryVectorParams extends QueryVectorParams<MongoDBVectorFilter> {
+    documentFilter?: MongoDBVectorFilter;
 }
-export { MongoDBQueryVectorParams }
-export { MongoDBQueryVectorParams as MongoDBQueryVectorParams_alias_1 }
 
 declare class MongoDBStore extends MastraStorage {
     #private;
@@ -207,7 +215,7 @@ declare interface MongoDBUpsertVectorParams extends UpsertVectorParams {
 export { MongoDBUpsertVectorParams }
 export { MongoDBUpsertVectorParams as MongoDBUpsertVectorParams_alias_1 }
 
-declare class MongoDBVector extends MastraVector {
+declare class MongoDBVector extends MastraVector<MongoDBVectorFilter> {
     private client;
     private db;
     private collections;
@@ -271,4 +279,6 @@ declare class MongoDBVector extends MastraVector {
 export { MongoDBVector }
 export { MongoDBVector as MongoDBVector_alias_1 }
 
+export declare type MongoDBVectorFilter = VectorFilter<keyof MongoDBOperatorValueMap, MongoDBOperatorValueMap, LogicalOperatorValueMap, MongoDBBlacklisted, VectorFieldValue | RegExp>;
+
 export { }

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

@@ -1,10 +1,12 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { BlacklistedRootOperators } from '@mastra/core/vector/filter';
 import type { CreateIndexParams } from '@mastra/core/vector';
 import type { DeleteIndexParams } from '@mastra/core/vector';
 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 { LogicalOperatorValueMap } from '@mastra/core/vector/filter';
 import type { MastraMessageContentV2 } from '@mastra/core/agent';
 import type { MastraMessageV1 } from '@mastra/core/memory';
 import type { MastraMessageV2 } from '@mastra/core/memory';
@@ -12,6 +14,7 @@ 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 { OperatorValueMap } 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';
@@ -23,6 +26,7 @@ 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 { VectorFieldValue } from '@mastra/core/vector/filter';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 import type { WorkflowRun } from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
@@ -35,6 +39,8 @@ declare const MONGODB_PROMPT = "When querying MongoDB Vector, you can ONLY use t
 export { MONGODB_PROMPT }
 export { MONGODB_PROMPT as MONGODB_PROMPT_alias_1 }
 
+declare type MongoDBBlacklisted = BlacklistedRootOperators | '$size';
+
 declare interface MongoDBConfig {
     url: string;
     dbName: string;
@@ -48,9 +54,9 @@ export { MongoDBConfig as MongoDBConfig_alias_1 }
  * Maintains MongoDB-compatible syntax while ensuring proper validation
  * and normalization of values.
  */
-export declare class MongoDBFilterTranslator extends BaseFilterTranslator {
+export declare class MongoDBFilterTranslator extends BaseFilterTranslator<MongoDBVectorFilter> {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: VectorFilter): any;
+    translate(filter?: MongoDBVectorFilter): any;
     private translateNode;
     private translateOperatorValue;
     isEmpty(filter: any): boolean;
@@ -64,11 +70,13 @@ declare interface MongoDBIndexReadyParams {
 export { MongoDBIndexReadyParams }
 export { MongoDBIndexReadyParams as MongoDBIndexReadyParams_alias_1 }
 
-declare interface MongoDBQueryVectorParams extends QueryVectorParams {
-    documentFilter?: VectorFilter;
+declare type MongoDBOperatorValueMap = Omit<OperatorValueMap, '$options'> & {
+    $size: number;
+};
+
+declare interface MongoDBQueryVectorParams extends QueryVectorParams<MongoDBVectorFilter> {
+    documentFilter?: MongoDBVectorFilter;
 }
-export { MongoDBQueryVectorParams }
-export { MongoDBQueryVectorParams as MongoDBQueryVectorParams_alias_1 }
 
 declare class MongoDBStore extends MastraStorage {
     #private;
@@ -207,7 +215,7 @@ declare interface MongoDBUpsertVectorParams extends UpsertVectorParams {
 export { MongoDBUpsertVectorParams }
 export { MongoDBUpsertVectorParams as MongoDBUpsertVectorParams_alias_1 }
 
-declare class MongoDBVector extends MastraVector {
+declare class MongoDBVector extends MastraVector<MongoDBVectorFilter> {
     private client;
     private db;
     private collections;
@@ -271,4 +279,6 @@ declare class MongoDBVector extends MastraVector {
 export { MongoDBVector }
 export { MongoDBVector as MongoDBVector_alias_1 }
 
+export declare type MongoDBVectorFilter = VectorFilter<keyof MongoDBOperatorValueMap, MongoDBOperatorValueMap, LogicalOperatorValueMap, MongoDBBlacklisted, VectorFieldValue | RegExp>;
+
 export { }

package/dist/index.cjs

@@ -912,7 +912,15 @@ var MongoDBStore = class extends storage.MastraStorage {
       const collection = await this.getCollection(storage.TABLE_MESSAGES);
       const threadsCollection = await this.getCollection(storage.TABLE_THREADS);
       await Promise.all([
-        collection.insertMany(messagesToInsert),
+        collection.bulkWrite(
+          messagesToInsert.map((msg) => ({
+            updateOne: {
+              filter: { id: msg.id },
+              update: { $set: msg },
+              upsert: true
+            }
+          }))
+        ),
         threadsCollection.updateOne({ id: threadId }, { $set: { updatedAt: /* @__PURE__ */ new Date() } })
       ]);
       const list = new agent.MessageList().add(messages, "memory");
@@ -938,15 +946,15 @@ var MongoDBStore = class extends storage.MastraStorage {
     const offset = page * perPage;
     const query = {};
     if (name) {
-      query["name"] = `%${name}%`;
+      query["name"] = new RegExp(name);
     }
     if (scope) {
       query["scope"] = scope;
     }
     if (attributes) {
-      Object.keys(attributes).forEach((key) => {
-        query[`attributes.${key}`] = attributes[key];
-      });
+      query["$and"] = Object.entries(attributes).map(([key, value]) => ({
+        attributes: new RegExp(`"${key}":"${value}"`)
+      }));
     }
     if (filters) {
       Object.entries(filters).forEach(([key, value]) => {
@@ -1220,10 +1228,19 @@ var MongoDBStore = class extends storage.MastraStorage {
         console.warn("Failed to parse test_info:", e);
       }
     }
+    const resultValue = JSON.parse(row.result);
+    if (!resultValue || typeof resultValue !== "object" || !("score" in resultValue)) {
+      throw new error.MastraError({
+        id: "STORAGE_MONGODB_STORE_INVALID_METRIC_FORMAT",
+        text: `Invalid MetricResult format: ${JSON.stringify(resultValue)}`,
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER
+      });
+    }
     return {
       input: row.input,
       output: row.output,
-      result: row.result,
+      result: resultValue,
       agentName: row.agent_name,
       metricName: row.metric_name,
       instructions: row.instructions,

package/dist/index.d.cts

@@ -1,6 +1,5 @@
 export { MONGODB_PROMPT } from './_tsup-dts-rollup.cjs';
 export { MongoDBUpsertVectorParams } from './_tsup-dts-rollup.cjs';
-export { MongoDBQueryVectorParams } from './_tsup-dts-rollup.cjs';
 export { MongoDBIndexReadyParams } from './_tsup-dts-rollup.cjs';
 export { MongoDBVector } from './_tsup-dts-rollup.cjs';
 export { MongoDBConfig } from './_tsup-dts-rollup.cjs';

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 export { MONGODB_PROMPT } from './_tsup-dts-rollup.js';
 export { MongoDBUpsertVectorParams } from './_tsup-dts-rollup.js';
-export { MongoDBQueryVectorParams } from './_tsup-dts-rollup.js';
 export { MongoDBIndexReadyParams } from './_tsup-dts-rollup.js';
 export { MongoDBVector } from './_tsup-dts-rollup.js';
 export { MongoDBConfig } from './_tsup-dts-rollup.js';

package/dist/index.js

@@ -910,7 +910,15 @@ var MongoDBStore = class extends MastraStorage {
       const collection = await this.getCollection(TABLE_MESSAGES);
       const threadsCollection = await this.getCollection(TABLE_THREADS);
       await Promise.all([
-        collection.insertMany(messagesToInsert),
+        collection.bulkWrite(
+          messagesToInsert.map((msg) => ({
+            updateOne: {
+              filter: { id: msg.id },
+              update: { $set: msg },
+              upsert: true
+            }
+          }))
+        ),
         threadsCollection.updateOne({ id: threadId }, { $set: { updatedAt: /* @__PURE__ */ new Date() } })
       ]);
       const list = new MessageList().add(messages, "memory");
@@ -936,15 +944,15 @@ var MongoDBStore = class extends MastraStorage {
     const offset = page * perPage;
     const query = {};
     if (name) {
-      query["name"] = `%${name}%`;
+      query["name"] = new RegExp(name);
     }
     if (scope) {
       query["scope"] = scope;
     }
     if (attributes) {
-      Object.keys(attributes).forEach((key) => {
-        query[`attributes.${key}`] = attributes[key];
-      });
+      query["$and"] = Object.entries(attributes).map(([key, value]) => ({
+        attributes: new RegExp(`"${key}":"${value}"`)
+      }));
     }
     if (filters) {
       Object.entries(filters).forEach(([key, value]) => {
@@ -1218,10 +1226,19 @@ var MongoDBStore = class extends MastraStorage {
         console.warn("Failed to parse test_info:", e);
       }
     }
+    const resultValue = JSON.parse(row.result);
+    if (!resultValue || typeof resultValue !== "object" || !("score" in resultValue)) {
+      throw new MastraError({
+        id: "STORAGE_MONGODB_STORE_INVALID_METRIC_FORMAT",
+        text: `Invalid MetricResult format: ${JSON.stringify(resultValue)}`,
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER
+      });
+    }
     return {
       input: row.input,
       output: row.output,
-      result: row.result,
+      result: resultValue,
       agentName: row.agent_name,
       metricName: row.metric_name,
       instructions: row.instructions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mongodb",
-  "version": "0.11.1-alpha.1",
+  "version": "0.11.1-alpha.2",
   "description": "MongoDB provider for Mastra - includes vector store capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -27,13 +27,13 @@
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.8",
     "@types/node": "^20.19.0",
-    "eslint": "^9.28.0",
+    "eslint": "^9.29.0",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.3",
+    "@internal/lint": "0.0.13",
     "@internal/storage-test-utils": "0.0.9",
-    "@mastra/core": "0.10.7-alpha.1",
-    "@internal/lint": "0.0.13"
+    "@mastra/core": "0.10.7-alpha.2"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.4-0 <0.11.0"

package/src/storage/index.test.ts

@@ -1,7 +1,13 @@
 import { randomUUID } from 'crypto';
 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 {
+  TABLE_EVALS,
+  TABLE_MESSAGES,
+  TABLE_THREADS,
+  TABLE_TRACES,
+  TABLE_WORKFLOW_SNAPSHOT,
+} from '@mastra/core/storage';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
 import type { MongoDBConfig } from './index';
 import { MongoDBStore } from './index';
@@ -23,6 +29,7 @@ class Test {
       await this.store.clearTable({ tableName: TABLE_MESSAGES });
       await this.store.clearTable({ tableName: TABLE_THREADS });
       await this.store.clearTable({ tableName: TABLE_EVALS });
+      await this.store.clearTable({ tableName: TABLE_TRACES });
     } catch (error) {
       // Ignore errors during table clearing
       console.warn('Error clearing tables:', error);
@@ -78,6 +85,7 @@ class Test {
       content: {
         format: 2,
         parts: [{ type: 'text', text: content }],
+        content: content,
       },
       createdAt: new Date(),
       resourceId,
@@ -354,6 +362,83 @@ describe('MongoDBStore', () => {
         expect((msg as any).content.parts).toEqual(messages[idx]!.content.parts);
       });
     });
+    it('should upsert messages: duplicate id+threadId results in update, not duplicate row', async () => {
+      const test = new Test(store).build();
+      await test.clearTables();
+      const thread = test.generateSampleThread();
+      await store.saveThread({ thread });
+      const baseMessage = test.generateSampleMessageV2({
+        threadId: thread.id,
+        content: 'Original',
+        resourceId: thread.resourceId,
+      });
+
+      // Insert the message for the first time
+      await store.saveMessages({ messages: [baseMessage], format: 'v2' });
+
+      // Insert again with the same id and threadId but different content
+      const updatedMessage = {
+        ...test.generateSampleMessageV2({
+          threadId: thread.id,
+          content: 'Updated',
+          resourceId: thread.resourceId,
+        }),
+        createdAt: baseMessage.createdAt,
+        id: baseMessage.id,
+      };
+
+      await store.saveMessages({ messages: [updatedMessage], format: 'v2' });
+
+      // Retrieve messages for the thread
+      const retrievedMessages = await store.getMessages({ threadId: thread.id, format: 'v2' });
+
+      // Only one message should exist for that id+threadId
+      expect(retrievedMessages.filter(m => m.id === baseMessage.id)).toHaveLength(1);
+
+      // The content should be the updated one
+      expect(retrievedMessages.find(m => m.id === baseMessage.id)?.content.content).toBe('Updated');
+    });
+
+    it('should upsert messages: duplicate id and different threadid', async () => {
+      const test = new Test(store).build();
+      const thread1 = test.generateSampleThread();
+      const thread2 = test.generateSampleThread();
+      await store.saveThread({ thread: thread1 });
+      await store.saveThread({ thread: thread2 });
+
+      const message = test.generateSampleMessageV2({
+        threadId: thread1.id,
+        content: 'Thread1 Content',
+        resourceId: thread1.resourceId,
+      });
+
+      // Insert message into thread1
+      await store.saveMessages({ messages: [message], format: 'v2' });
+
+      // Attempt to insert a message with the same id but different threadId
+      const conflictingMessage = {
+        ...test.generateSampleMessageV2({
+          threadId: thread2.id, // different thread
+          content: 'Thread2 Content',
+          resourceId: thread2.resourceId,
+        }),
+        createdAt: message.createdAt,
+        id: message.id,
+      };
+
+      // Save should move the message to the new thread
+      await store.saveMessages({ messages: [conflictingMessage], format: 'v2' });
+
+      // Retrieve messages for both threads
+      const thread1Messages = await store.getMessages({ threadId: thread1.id, format: 'v2' });
+      const thread2Messages = await store.getMessages({ threadId: thread2.id, format: 'v2' });
+
+      // Thread 1 should NOT have the message with that id
+      expect(thread1Messages.find(m => m.id === message.id)).toBeUndefined();
+
+      // Thread 2 should have the message with that id
+      expect(thread2Messages.find(m => m.id === message.id)?.content.content).toBe('Thread2 Content');
+    });
 
     // it('should retrieve messages w/ next/prev messages by message id + resource id', async () => {
     //   const test = new Test(store).build();
@@ -846,6 +931,152 @@ describe('MongoDBStore', () => {
     });
   });
 
+  describe('Trace Operations', () => {
+    const sampleTrace = (
+      name: string,
+      scope: string,
+      startTime = Date.now(),
+      attributes: Record<string, string> = {},
+    ) => ({
+      id: `trace-${randomUUID()}`,
+      parentSpanId: `span-${randomUUID()}`,
+      traceId: `traceid-${randomUUID()}`,
+      name,
+      scope,
+      kind: 1,
+      startTime: startTime,
+      endTime: startTime + 100,
+      status: JSON.stringify({ code: 0 }),
+      attributes: JSON.stringify({ key: 'value', scopeAttr: scope, ...attributes }),
+      events: JSON.stringify([{ name: 'event1', timestamp: startTime + 50 }]),
+      links: JSON.stringify([]),
+      createdAt: new Date(startTime).toISOString(),
+      updatedAt: new Date(startTime).toISOString(),
+    });
+
+    beforeEach(async () => {
+      const test = new Test(store).build();
+      await test.clearTables();
+    });
+
+    it('should batch insert and retrieve traces', async () => {
+      const trace1 = sampleTrace('trace-op-1', 'scope-A');
+      const trace2 = sampleTrace('trace-op-2', 'scope-A', Date.now() + 10);
+      const trace3 = sampleTrace('trace-op-3', 'scope-B', Date.now() + 20);
+      const records = [trace1, trace2, trace3];
+
+      await store.batchInsert({ tableName: TABLE_TRACES, records });
+
+      const allTraces = await store.getTraces();
+      expect(allTraces.length).toBe(3);
+    });
+
+    it('should handle Date objects for createdAt/updatedAt fields in batchInsert', async () => {
+      const now = new Date();
+      const traceWithDateObjects = {
+        id: `trace-${randomUUID()}`,
+        parentSpanId: `span-${randomUUID()}`,
+        traceId: `traceid-${randomUUID()}`,
+        name: 'test-trace-with-dates',
+        scope: 'default-tracer',
+        kind: 1,
+        startTime: now.getTime(),
+        endTime: now.getTime() + 100,
+        status: JSON.stringify({ code: 0 }),
+        attributes: JSON.stringify({ key: 'value' }),
+        events: JSON.stringify([]),
+        links: JSON.stringify([]),
+        createdAt: now,
+        updatedAt: now,
+      };
+
+      await store.batchInsert({ tableName: TABLE_TRACES, records: [traceWithDateObjects] });
+
+      const allTraces = await store.getTraces({ name: 'test-trace-with-dates', page: 0, perPage: 10 });
+      expect(allTraces.length).toBe(1);
+      expect(allTraces[0].name).toBe('test-trace-with-dates');
+    });
+
+    it('should retrieve traces filtered by name', async () => {
+      const now = Date.now();
+      const trace1 = sampleTrace('trace-filter-name', 'scope-X', now);
+      const trace2 = sampleTrace('trace-filter-name', 'scope-Y', now + 10);
+      const trace3 = sampleTrace('other-name', 'scope-X', now + 20);
+      await store.batchInsert({ tableName: TABLE_TRACES, records: [trace1, trace2, trace3] });
+
+      const filteredTraces = await store.getTraces({ name: 'trace-filter-name', page: 0, perPage: 10 });
+      expect(filteredTraces.length).toBe(2);
+      expect(filteredTraces.every(t => t.name === 'trace-filter-name')).toBe(true);
+      expect(filteredTraces[0].scope).toBe('scope-Y');
+      expect(filteredTraces[1].scope).toBe('scope-X');
+    });
+
+    it('should retrieve traces filtered by attributes', async () => {
+      const now = Date.now();
+      const trace1 = sampleTrace('trace-filter-attribute-A', 'scope-X', now, { componentName: 'component-TARGET' });
+      const trace2 = sampleTrace('trace-filter-attribute-B', 'scope-Y', now + 10, { componentName: 'component-OTHER' });
+      const trace3 = sampleTrace('trace-filter-attribute-C', 'scope-Z', now + 20, {
+        componentName: 'component-TARGET',
+        andFilterTest: 'TARGET',
+      });
+      await store.batchInsert({ tableName: TABLE_TRACES, records: [trace1, trace2, trace3] });
+
+      const filteredTraces = await store.getTraces({
+        attributes: { componentName: 'component-TARGET' },
+        page: 0,
+        perPage: 10,
+      });
+      expect(filteredTraces.length).toBe(2);
+      expect(filteredTraces[0].name).toBe('trace-filter-attribute-C');
+      expect(filteredTraces[1].name).toBe('trace-filter-attribute-A');
+
+      const filteredTraces2 = await store.getTraces({
+        attributes: { componentName: 'component-TARGET', andFilterTest: 'TARGET' },
+        page: 0,
+        perPage: 10,
+      });
+      expect(filteredTraces2.length).toBe(1);
+      expect(filteredTraces2[0].name).toBe('trace-filter-attribute-C');
+    });
+
+    it('should retrieve traces filtered by scope', async () => {
+      const now = Date.now();
+      const trace1 = sampleTrace('trace-filter-scope-A', 'scope-TARGET', now);
+      const trace2 = sampleTrace('trace-filter-scope-B', 'scope-OTHER', now + 10);
+      const trace3 = sampleTrace('trace-filter-scope-C', 'scope-TARGET', now + 20);
+      await store.batchInsert({ tableName: TABLE_TRACES, records: [trace1, trace2, trace3] });
+
+      const filteredTraces = await store.getTraces({ scope: 'scope-TARGET', page: 0, perPage: 10 });
+      expect(filteredTraces.length).toBe(2);
+      expect(filteredTraces.every(t => t.scope === 'scope-TARGET')).toBe(true);
+      expect(filteredTraces[0].name).toBe('trace-filter-scope-C');
+      expect(filteredTraces[1].name).toBe('trace-filter-scope-A');
+    });
+
+    it('should handle pagination for getTraces', async () => {
+      const now = Date.now();
+      const traceData = Array.from({ length: 5 }, (_, i) => sampleTrace('trace-page', `scope-page`, now + i * 10));
+      await store.batchInsert({ tableName: TABLE_TRACES, records: traceData });
+
+      const page1 = await store.getTraces({ name: 'trace-page', page: 0, perPage: 2 });
+      expect(page1.length).toBe(2);
+      expect(page1[0]!.startTime).toBe(traceData[4]!.startTime);
+      expect(page1[1]!.startTime).toBe(traceData[3]!.startTime);
+
+      const page2 = await store.getTraces({ name: 'trace-page', page: 1, perPage: 2 });
+      expect(page2.length).toBe(2);
+      expect(page2[0]!.startTime).toBe(traceData[2]!.startTime);
+      expect(page2[1]!.startTime).toBe(traceData[1]!.startTime);
+
+      const page3 = await store.getTraces({ name: 'trace-page', page: 2, perPage: 2 });
+      expect(page3.length).toBe(1);
+      expect(page3[0]!.startTime).toBe(traceData[0]!.startTime);
+
+      const page4 = await store.getTraces({ name: 'trace-page', page: 3, perPage: 2 });
+      expect(page4.length).toBe(0);
+    });
+  });
+
   describe('Eval Operations', () => {
     it('should retrieve evals by agent name', async () => {
       const test = new Test(store).build();
@@ -864,7 +1095,7 @@ describe('MongoDBStore', () => {
           agent_name: liveEval.agentName,
           input: liveEval.input,
           output: liveEval.output,
-          result: liveEval.result,
+          result: JSON.stringify(liveEval.result),
           metric_name: liveEval.metricName,
           instructions: liveEval.instructions,
           test_info: null,
@@ -881,7 +1112,7 @@ describe('MongoDBStore', () => {
           agent_name: testEval.agentName,
           input: testEval.input,
           output: testEval.output,
-          result: testEval.result,
+          result: JSON.stringify(testEval.result),
           metric_name: testEval.metricName,
           instructions: testEval.instructions,
           test_info: JSON.stringify(testEval.testInfo),
@@ -898,7 +1129,7 @@ describe('MongoDBStore', () => {
           agent_name: otherAgentEval.agentName,
           input: otherAgentEval.input,
           output: otherAgentEval.output,
-          result: otherAgentEval.result,
+          result: JSON.stringify(otherAgentEval.result),
           metric_name: otherAgentEval.metricName,
           instructions: otherAgentEval.instructions,
           test_info: null,
@@ -913,16 +1144,20 @@ describe('MongoDBStore', () => {
       const allEvals = await store.getEvalsByAgentName(agentName);
       expect(allEvals).toHaveLength(2);
       expect(allEvals.map(e => e.runId)).toEqual(expect.arrayContaining([liveEval.runId, testEval.runId]));
+      expect(allEvals[0]!.result.score).toEqual(liveEval.result.score);
+      expect(allEvals[1]!.result.score).toEqual(testEval.result.score);
 
       // Test getting only live evals
       const liveEvals = await store.getEvalsByAgentName(agentName, 'live');
       expect(liveEvals).toHaveLength(1);
       expect(liveEvals[0]!.runId).toBe(liveEval.runId);
+      expect(liveEvals[0]!.result.score).toEqual(liveEval.result.score);
 
       // Test getting only test evals
       const testEvals = await store.getEvalsByAgentName(agentName, 'test');
       expect(testEvals).toHaveLength(1);
       expect(testEvals[0]!.runId).toBe(testEval.runId);
+      expect(testEvals[0]!.result.score).toEqual(testEval.result.score);
       expect(testEvals[0]!.testInfo).toEqual(testEval.testInfo);
 
       // Test getting evals for non-existent agent

package/src/storage/index.ts

@@ -462,7 +462,15 @@ export class MongoDBStore extends MastraStorage {
       const threadsCollection = await this.getCollection(TABLE_THREADS);
 
       await Promise.all([
-        collection.insertMany(messagesToInsert),
+        collection.bulkWrite(
+          messagesToInsert.map(msg => ({
+            updateOne: {
+              filter: { id: msg.id },
+              update: { $set: msg },
+              upsert: true,
+            },
+          })),
+        ),
         threadsCollection.updateOne({ id: threadId }, { $set: { updatedAt: new Date() } }),
       ]);
 
@@ -500,7 +508,7 @@ export class MongoDBStore extends MastraStorage {
 
     const query: any = {};
     if (name) {
-      query['name'] = `%${name}%`;
+      query['name'] = new RegExp(name);
     }
 
     if (scope) {
@@ -508,9 +516,9 @@ export class MongoDBStore extends MastraStorage {
     }
 
     if (attributes) {
-      Object.keys(attributes).forEach(key => {
-        query[`attributes.${key}`] = attributes[key];
-      });
+      query['$and'] = Object.entries(attributes).map(([key, value]) => ({
+        attributes: new RegExp(`\"${key}\":\"${value}\"`),
+      }));
     }
 
     if (filters) {
@@ -852,11 +860,20 @@ export class MongoDBStore extends MastraStorage {
         console.warn('Failed to parse test_info:', e);
       }
     }
+    const resultValue = JSON.parse(row.result as string);
+    if (!resultValue || typeof resultValue !== 'object' || !('score' in resultValue)) {
+      throw new MastraError({
+        id: 'STORAGE_MONGODB_STORE_INVALID_METRIC_FORMAT',
+        text: `Invalid MetricResult format: ${JSON.stringify(resultValue)}`,
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+      });
+    }
 
     return {
       input: row.input as string,
       output: row.output as string,
-      result: row.result as MetricResult,
+      result: resultValue as MetricResult,
       agentName: row.agent_name as string,
       metricName: row.metric_name as string,
       instructions: row.instructions as string,

package/src/vector/filter.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 
+import type { MongoDBVectorFilter } from './filter';
 import { MongoDBFilterTranslator } from './filter';
 
 describe('MongoDBFilterTranslator', () => {
@@ -12,12 +13,12 @@ describe('MongoDBFilterTranslator', () => {
   // Basic Filter Operations
   describe('basic operations', () => {
     it('handles simple equality', () => {
-      const filter = { field: 'value' };
+      const filter: MongoDBVectorFilter = { field: 'value' };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles comparison operators', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         age: { $gt: 25 },
         score: { $lte: 100 },
       };
@@ -25,7 +26,7 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles valid multiple operators on same field', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         price: { $gt: 100, $lt: 200 },
         quantity: { $gte: 10, $lte: 20 },
       };
@@ -33,7 +34,7 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles null values correctly', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         field: null,
         other: { $eq: null },
       };
@@ -41,7 +42,7 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles boolean values correctly', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         active: true,
         deleted: false,
         status: { $eq: true },
@@ -53,7 +54,7 @@ describe('MongoDBFilterTranslator', () => {
   // Array Operations
   describe('array operations', () => {
     it('handles array operators', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         tags: { $all: ['tag1', 'tag2'] },
         categories: { $in: ['A', 'B'] },
         items: { $nin: ['item1', 'item2'] },
@@ -63,7 +64,7 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles empty array values', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         tags: { $in: [] },
         categories: { $all: [] },
       };
@@ -71,14 +72,14 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles nested array operators', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         $and: [{ tags: { $all: ['tag1', 'tag2'] } }, { 'nested.array': { $in: [1, 2, 3] } }],
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles $size operator', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         tags: { $size: 3 },
       };
       expect(translator.translate(filter)).toEqual(filter);
@@ -88,14 +89,14 @@ describe('MongoDBFilterTranslator', () => {
   // Logical Operators
   describe('logical operators', () => {
     it('handles logical operators', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         $or: [{ status: 'active' }, { age: { $gt: 25 } }],
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles $not operator', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         field: { $not: { $eq: 'value' } },
         $not: { field: 'value' },
       };
@@ -103,14 +104,14 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles $nor operator', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         $nor: [{ status: 'deleted' }, { active: false }],
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles nested logical operators', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         $and: [
           { status: 'active' },
           { $or: [{ category: { $in: ['A', 'B'] } }, { $and: [{ price: { $gt: 100 } }, { stock: { $lt: 50 } }] }] },
@@ -120,7 +121,7 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles empty conditions in logical operators', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         $and: [],
         $or: [{}],
         field: 'value',
@@ -175,7 +176,7 @@ describe('MongoDBFilterTranslator', () => {
       expect(() =>
         translator.translate({
           $or: [{ $in: ['value1', 'value2'] }],
-        }),
+        } as any),
       ).toThrow(/Logical operators must contain field conditions/);
     });
 
@@ -187,7 +188,7 @@ describe('MongoDBFilterTranslator', () => {
               $or: [{ subfield: 'value1' }, { subfield: 'value2' }],
             },
           },
-        }),
+        } as any),
       ).toThrow();
 
       expect(() =>
@@ -196,7 +197,7 @@ describe('MongoDBFilterTranslator', () => {
             $in: [
               {
                 $and: [{ subfield: 'value1' }, { subfield: 'value2' }],
-              },
+              } as any,
             ],
           },
         }),
@@ -211,7 +212,7 @@ describe('MongoDBFilterTranslator', () => {
               $or: [{ subfield: 'value1' }, { subfield: 'value2' }],
             },
           },
-        }),
+        } as any),
       ).toThrow();
 
       expect(() =>
@@ -227,7 +228,7 @@ describe('MongoDBFilterTranslator', () => {
 
     it('throws error for $not if not an object', () => {
       expect(() => translator.translate({ $not: 'value' })).toThrow();
-      expect(() => translator.translate({ $not: [{ field: 'value' }] })).toThrow();
+      expect(() => translator.translate({ $not: [{ field: 'value' }] } as any)).toThrow();
     });
 
     it('throws error for $not if empty', () => {
@@ -238,7 +239,7 @@ describe('MongoDBFilterTranslator', () => {
   // Nested Objects and Fields
   describe('nested objects and fields', () => {
     it('handles nested objects', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         'user.profile.age': { $gt: 25 },
         'user.status': 'active',
       };
@@ -246,7 +247,7 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('handles deeply nested field paths', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         'user.profile.address.city': { $eq: 'New York' },
         'deep.nested.field': { $gt: 100 },
       };
@@ -295,13 +296,13 @@ describe('MongoDBFilterTranslator', () => {
   describe('special cases', () => {
     it('handles empty filters', () => {
       expect(translator.translate({})).toEqual({});
-      expect(translator.translate(null as any)).toEqual(null);
-      expect(translator.translate(undefined as any)).toEqual(undefined);
+      expect(translator.translate(null)).toEqual(null);
+      expect(translator.translate(undefined)).toEqual(undefined);
     });
 
     it('normalizes dates', () => {
       const date = new Date('2024-01-01');
-      const filter = { timestamp: { $gt: date } };
+      const filter: MongoDBVectorFilter = { timestamp: { $gt: date } };
       expect(translator.translate(filter)).toEqual({
         timestamp: { $gt: date.toISOString() },
       });
@@ -321,14 +322,14 @@ describe('MongoDBFilterTranslator', () => {
   // Regex Support
   describe('regex support', () => {
     it('handles $regex operator', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         name: { $regex: '^test' },
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles RegExp objects', () => {
-      const filter = {
+      const filter: MongoDBVectorFilter = {
         name: /^test/i,
       };
       // RegExp objects should be preserved
@@ -338,7 +339,7 @@ describe('MongoDBFilterTranslator', () => {
 
   describe('operator validation', () => {
     it('ensures all supported operator filters are accepted', () => {
-      const supportedFilters = [
+      const supportedFilters: MongoDBVectorFilter[] = [
         // Basic comparison operators
         { field: { $eq: 'value' } },
         { field: { $ne: 'value' } },
@@ -382,12 +383,21 @@ describe('MongoDBFilterTranslator', () => {
     });
 
     it('throws on unsupported operators', () => {
-      expect(() => translator.translate({ field: { $unknown: 'value' } })).toThrow('Unsupported operator: $unknown');
-      expect(() => translator.translate({ $unknown: [{ field: 'value' }] })).toThrow('Unsupported operator: $unknown');
+      expect(() => translator.translate({ field: { $unknown: 'value' } } as any)).toThrow(
+        'Unsupported operator: $unknown',
+      );
+      expect(() => translator.translate({ $unknown: [{ field: 'value' }] } as any)).toThrow(
+        'Unsupported operator: $unknown',
+      );
     });
 
     it('throws error for non-logical operators at top level', () => {
-      const invalidFilters = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $exists: true }, { $regex: 'pattern' }];
+      const invalidFilters: any = [
+        { $gt: 100 },
+        { $in: ['value1', 'value2'] },
+        { $exists: true },
+        { $regex: 'pattern' },
+      ];
 
       invalidFilters.forEach(filter => {
         expect(() => translator.translate(filter)).toThrow(/Invalid top-level operator/);

package/src/vector/filter.ts

@@ -1,12 +1,33 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
-import type { FieldCondition, VectorFilter, OperatorSupport, QueryOperator } from '@mastra/core/vector/filter';
+import type {
+  VectorFilter,
+  OperatorSupport,
+  QueryOperator,
+  OperatorValueMap,
+  LogicalOperatorValueMap,
+  BlacklistedRootOperators,
+  VectorFieldValue,
+} from '@mastra/core/vector/filter';
+
+type MongoDBOperatorValueMap = Omit<OperatorValueMap, '$options'> & {
+  $size: number;
+};
+type MongoDBBlacklisted = BlacklistedRootOperators | '$size';
+
+export type MongoDBVectorFilter = VectorFilter<
+  keyof MongoDBOperatorValueMap,
+  MongoDBOperatorValueMap,
+  LogicalOperatorValueMap,
+  MongoDBBlacklisted,
+  VectorFieldValue | RegExp
+>;
 
 /**
  * Translator for MongoDB filter queries.
  * Maintains MongoDB-compatible syntax while ensuring proper validation
  * and normalization of values.
  */
-export class MongoDBFilterTranslator extends BaseFilterTranslator {
+export class MongoDBFilterTranslator extends BaseFilterTranslator<MongoDBVectorFilter> {
   protected override getSupportedOperators(): OperatorSupport {
     return {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
@@ -15,14 +36,14 @@ export class MongoDBFilterTranslator extends BaseFilterTranslator {
     };
   }
 
-  translate(filter?: VectorFilter): any {
+  translate(filter?: MongoDBVectorFilter): any {
     if (this.isEmpty(filter)) return filter;
     this.validateFilter(filter);
 
     return this.translateNode(filter);
   }
 
-  private translateNode(node: VectorFilter | FieldCondition): any {
+  private translateNode(node: MongoDBVectorFilter): any {
     // Handle primitive values and arrays
     if (this.isRegex(node)) {
       return node; // Return regex values as-is

package/src/vector/index.test.ts

@@ -1,4 +1,3 @@
-import type { VectorFilter } from '@mastra/core/vector/filter';
 import { vi, describe, it, expect, beforeAll, afterAll, test } from 'vitest';
 import { MongoDBVector } from './';
 
@@ -329,7 +328,7 @@ describe('MongoDBVector Integration Tests', () => {
       const results = await retryQuery({
         indexName: testIndexName2,
         queryVector: [1, 0, 0, 0],
-        filter: null as unknown as VectorFilter,
+        filter: null,
       });
       const results2 = await retryQuery({
         indexName: testIndexName2,

package/src/vector/index.ts

@@ -11,20 +11,20 @@ import type {
   DeleteVectorParams,
   UpdateVectorParams,
 } from '@mastra/core/vector';
-import type { VectorFilter } from '@mastra/core/vector/filter';
 import { MongoClient } from 'mongodb';
 import type { MongoClientOptions, Document, Db, Collection } from 'mongodb';
 import { v4 as uuidv4 } from 'uuid';
 
 import { MongoDBFilterTranslator } from './filter';
+import type { MongoDBVectorFilter } from './filter';
 
 // Define necessary types and interfaces
 export interface MongoDBUpsertVectorParams extends UpsertVectorParams {
   documents?: string[];
 }
 
-export interface MongoDBQueryVectorParams extends QueryVectorParams {
-  documentFilter?: VectorFilter;
+interface MongoDBQueryVectorParams extends QueryVectorParams<MongoDBVectorFilter> {
+  documentFilter?: MongoDBVectorFilter;
 }
 
 export interface MongoDBIndexReadyParams {
@@ -42,7 +42,7 @@ interface MongoDBDocument extends Document {
   [key: string]: any; // Index signature for additional properties
 }
 // The MongoDBVector class
-export class MongoDBVector extends MastraVector {
+export class MongoDBVector extends MastraVector<MongoDBVectorFilter> {
   private client: MongoClient;
   private db: Db;
   private collections: Map<string, Collection<MongoDBDocument>>;
@@ -558,7 +558,7 @@ export class MongoDBVector extends MastraVector {
     await collection.updateOne({ _id: '__index_metadata__' }, { $set: { dimension } }, { upsert: true });
   }
 
-  private transformFilter(filter?: VectorFilter): any {
+  private transformFilter(filter?: MongoDBVectorFilter) {
     const translator = new MongoDBFilterTranslator();
     if (!filter) return {};
     return translator.translate(filter);