@mastra/memory 0.10.2-alpha.1 → 0.10.2

package/.turbo/turbo-build.log

@@ -1,9 +1,9 @@
 
-> @mastra/memory@0.10.2-alpha.1 build /home/runner/work/mastra/mastra/packages/memory
+> @mastra/memory@0.10.2-alpha.2 build /home/runner/work/mastra/mastra/packages/memory
 > pnpm run check && tsup --silent src/index.ts src/processors/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 
-> @mastra/memory@0.10.2-alpha.1 check /home/runner/work/mastra/mastra/packages/memory
+> @mastra/memory@0.10.2-alpha.2 check /home/runner/work/mastra/mastra/packages/memory
 > tsc --noEmit
 
 Analysis will use the bundled TypeScript version 5.8.3

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # @mastra/memory
 
+## 0.10.2
+
+### Patch Changes
+
+- e5dc18d: Added a backwards compatible layer to begin storing/retrieving UIMessages in storage instead of CoreMessages
+- 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.2
+
+### 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.1
 
 ### Patch Changes

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

@@ -1,4 +1,5 @@
-import type { CoreMessage } from '@mastra/core';
+import type { CoreMessage } from 'ai';
+import type { CoreMessage as CoreMessage_2 } from '@mastra/core';
 import type { CoreTool } from '@mastra/core';
 import { MastraMemory } from '@mastra/core/memory';
 import type { MastraMessageV1 } from '@mastra/core';
@@ -23,8 +24,9 @@ export declare class Memory extends MastraMemory {
     query({ threadId, resourceId, selectBy, threadConfig, }: StorageGetMessagesArg & {
         threadConfig?: MemoryConfig;
     }): Promise<{
-        messages: MastraMessageV1[];
+        messages: CoreMessage[];
         uiMessages: UIMessage[];
+        messagesV2: MastraMessageV2[];
     }>;
     rememberMessages({ threadId, resourceId, vectorMessageSearch, config, }: {
         threadId: string;
@@ -56,9 +58,15 @@ export declare class Memory extends MastraMemory {
     private embeddingCache;
     private firstEmbed;
     private embedMessageContent;
-    saveMessages({ messages, memoryConfig, }: {
-        messages: (MastraMessageV1 | MastraMessageV2)[];
-        memoryConfig?: MemoryConfig;
+    saveMessages(args: {
+        messages: (MastraMessageV1 | MastraMessageV2)[] | MastraMessageV1[] | MastraMessageV2[];
+        memoryConfig?: MemoryConfig | undefined;
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: (MastraMessageV1 | MastraMessageV2)[] | MastraMessageV1[] | MastraMessageV2[];
+        memoryConfig?: MemoryConfig | undefined;
+        format: 'v2';
     }): Promise<MastraMessageV2[]>;
     protected updateMessageToHideWorkingMemory(message: MastraMessageV1): MastraMessageV1 | null;
     protected updateMessageToHideWorkingMemoryV2(message: MastraMessageV2): MastraMessageV2 | null;
@@ -90,8 +98,8 @@ declare class TokenLimiter extends MemoryProcessor {
      * @param options Either a number (token limit) or a configuration object
      */
     constructor(options: number | TokenLimiterOptions);
-    process(messages: CoreMessage[], { systemMessage, memorySystemMessage, newMessages }?: MemoryProcessorOpts): CoreMessage[];
-    countTokens(message: string | CoreMessage): number;
+    process(messages: CoreMessage_2[], { systemMessage, memorySystemMessage, newMessages }?: MemoryProcessorOpts): CoreMessage_2[];
+    countTokens(message: string | CoreMessage_2): number;
 }
 export { TokenLimiter }
 export { TokenLimiter as TokenLimiter_alias_1 }
@@ -121,7 +129,7 @@ declare class ToolCallFilter extends MemoryProcessor_2 {
     constructor(options?: {
         exclude?: string[];
     });
-    process(messages: CoreMessage[]): CoreMessage[];
+    process(messages: CoreMessage_2[]): CoreMessage_2[];
 }
 export { ToolCallFilter }
 export { ToolCallFilter as ToolCallFilter_alias_1 }

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

@@ -1,4 +1,5 @@
-import type { CoreMessage } from '@mastra/core';
+import type { CoreMessage } from 'ai';
+import type { CoreMessage as CoreMessage_2 } from '@mastra/core';
 import type { CoreTool } from '@mastra/core';
 import { MastraMemory } from '@mastra/core/memory';
 import type { MastraMessageV1 } from '@mastra/core';
@@ -23,8 +24,9 @@ export declare class Memory extends MastraMemory {
     query({ threadId, resourceId, selectBy, threadConfig, }: StorageGetMessagesArg & {
         threadConfig?: MemoryConfig;
     }): Promise<{
-        messages: MastraMessageV1[];
+        messages: CoreMessage[];
         uiMessages: UIMessage[];
+        messagesV2: MastraMessageV2[];
     }>;
     rememberMessages({ threadId, resourceId, vectorMessageSearch, config, }: {
         threadId: string;
@@ -56,9 +58,15 @@ export declare class Memory extends MastraMemory {
     private embeddingCache;
     private firstEmbed;
     private embedMessageContent;
-    saveMessages({ messages, memoryConfig, }: {
-        messages: (MastraMessageV1 | MastraMessageV2)[];
-        memoryConfig?: MemoryConfig;
+    saveMessages(args: {
+        messages: (MastraMessageV1 | MastraMessageV2)[] | MastraMessageV1[] | MastraMessageV2[];
+        memoryConfig?: MemoryConfig | undefined;
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: (MastraMessageV1 | MastraMessageV2)[] | MastraMessageV1[] | MastraMessageV2[];
+        memoryConfig?: MemoryConfig | undefined;
+        format: 'v2';
     }): Promise<MastraMessageV2[]>;
     protected updateMessageToHideWorkingMemory(message: MastraMessageV1): MastraMessageV1 | null;
     protected updateMessageToHideWorkingMemoryV2(message: MastraMessageV2): MastraMessageV2 | null;
@@ -90,8 +98,8 @@ declare class TokenLimiter extends MemoryProcessor {
      * @param options Either a number (token limit) or a configuration object
      */
     constructor(options: number | TokenLimiterOptions);
-    process(messages: CoreMessage[], { systemMessage, memorySystemMessage, newMessages }?: MemoryProcessorOpts): CoreMessage[];
-    countTokens(message: string | CoreMessage): number;
+    process(messages: CoreMessage_2[], { systemMessage, memorySystemMessage, newMessages }?: MemoryProcessorOpts): CoreMessage_2[];
+    countTokens(message: string | CoreMessage_2): number;
 }
 export { TokenLimiter }
 export { TokenLimiter as TokenLimiter_alias_1 }
@@ -121,7 +129,7 @@ declare class ToolCallFilter extends MemoryProcessor_2 {
     constructor(options?: {
         exclude?: string[];
     });
-    process(messages: CoreMessage[]): CoreMessage[];
+    process(messages: CoreMessage_2[]): CoreMessage_2[];
 }
 export { ToolCallFilter }
 export { ToolCallFilter as ToolCallFilter_alias_1 }

package/dist/index.cjs

@@ -116,6 +116,7 @@ var Memory = class extends memory.MastraMemory {
     }
     const rawMessages = await this.storage.getMessages({
       threadId,
+      format: "v2",
       selectBy: {
         ...selectBy,
         ...vectorResults?.length ? {
@@ -128,8 +129,7 @@ var Memory = class extends memory.MastraMemory {
       },
       threadConfig: config
     });
-    const orderedByDate = rawMessages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-    const list = new agent.MessageList({ threadId, resourceId }).add(orderedByDate, "memory");
+    const list = new agent.MessageList({ threadId, resourceId }).add(rawMessages, "memory");
     return {
       get messages() {
         const v1Messages = list.get.all.v1();
@@ -140,6 +140,9 @@ var Memory = class extends memory.MastraMemory {
       },
       get uiMessages() {
         return list.get.all.ui();
+      },
+      get messagesV2() {
+        return list.get.all.v2();
       }
     };
   }
@@ -163,11 +166,12 @@ var Memory = class extends memory.MastraMemory {
         last: threadConfig.lastMessages,
         vectorSearchString: threadConfig.semanticRecall && vectorMessageSearch ? vectorMessageSearch : void 0
       },
-      threadConfig: config
+      threadConfig: config,
+      format: "v2"
     });
-    const list = new agent.MessageList({ threadId, resourceId }).add(messagesResult.messages, "memory");
+    const list = new agent.MessageList({ threadId, resourceId }).add(messagesResult.messagesV2, "memory");
     this.logger.debug(`Remembered message history includes ${messagesResult.messages.length} messages.`);
-    return { messages: list.get.all.v1(), messagesV2: list.get.all.mastra() };
+    return { messages: list.get.all.v1(), messagesV2: list.get.all.v2() };
   }
   async getThreadById({ threadId }) {
     return this.storage.getThreadById({ threadId });
@@ -257,7 +261,8 @@ var Memory = class extends memory.MastraMemory {
   }
   async saveMessages({
     messages,
-    memoryConfig
+    memoryConfig,
+    format = `v1`
   }) {
     const updatedMessages = messages.map((m) => {
       if (agent.MessageList.isMastraMessageV1(m)) {
@@ -267,7 +272,10 @@ var Memory = class extends memory.MastraMemory {
       return this.updateMessageToHideWorkingMemoryV2(m);
     }).filter((m) => Boolean(m));
     const config = this.getMergedThreadConfig(memoryConfig);
-    const result = this.storage.saveMessages({ messages: updatedMessages });
+    const result = this.storage.saveMessages({
+      messages: new agent.MessageList().add(updatedMessages, "memory").get.all.v2(),
+      format: "v2"
+    });
     if (this.vector && config.semanticRecall) {
       let indexName;
       await Promise.all(
@@ -310,6 +318,7 @@ var Memory = class extends memory.MastraMemory {
         })
       );
     }
+    if (format === `v1`) return new agent.MessageList().add(await result, "memory").get.all.v1();
     return result;
   }
   updateMessageToHideWorkingMemory(message) {

package/dist/index.js

@@ -110,6 +110,7 @@ var Memory = class extends MastraMemory {
     }
     const rawMessages = await this.storage.getMessages({
       threadId,
+      format: "v2",
       selectBy: {
         ...selectBy,
         ...vectorResults?.length ? {
@@ -122,8 +123,7 @@ var Memory = class extends MastraMemory {
       },
       threadConfig: config
     });
-    const orderedByDate = rawMessages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-    const list = new MessageList({ threadId, resourceId }).add(orderedByDate, "memory");
+    const list = new MessageList({ threadId, resourceId }).add(rawMessages, "memory");
     return {
       get messages() {
         const v1Messages = list.get.all.v1();
@@ -134,6 +134,9 @@ var Memory = class extends MastraMemory {
       },
       get uiMessages() {
         return list.get.all.ui();
+      },
+      get messagesV2() {
+        return list.get.all.v2();
       }
     };
   }
@@ -157,11 +160,12 @@ var Memory = class extends MastraMemory {
         last: threadConfig.lastMessages,
         vectorSearchString: threadConfig.semanticRecall && vectorMessageSearch ? vectorMessageSearch : void 0
       },
-      threadConfig: config
+      threadConfig: config,
+      format: "v2"
     });
-    const list = new MessageList({ threadId, resourceId }).add(messagesResult.messages, "memory");
+    const list = new MessageList({ threadId, resourceId }).add(messagesResult.messagesV2, "memory");
     this.logger.debug(`Remembered message history includes ${messagesResult.messages.length} messages.`);
-    return { messages: list.get.all.v1(), messagesV2: list.get.all.mastra() };
+    return { messages: list.get.all.v1(), messagesV2: list.get.all.v2() };
   }
   async getThreadById({ threadId }) {
     return this.storage.getThreadById({ threadId });
@@ -251,7 +255,8 @@ var Memory = class extends MastraMemory {
   }
   async saveMessages({
     messages,
-    memoryConfig
+    memoryConfig,
+    format = `v1`
   }) {
     const updatedMessages = messages.map((m) => {
       if (MessageList.isMastraMessageV1(m)) {
@@ -261,7 +266,10 @@ var Memory = class extends MastraMemory {
       return this.updateMessageToHideWorkingMemoryV2(m);
     }).filter((m) => Boolean(m));
     const config = this.getMergedThreadConfig(memoryConfig);
-    const result = this.storage.saveMessages({ messages: updatedMessages });
+    const result = this.storage.saveMessages({
+      messages: new MessageList().add(updatedMessages, "memory").get.all.v2(),
+      format: "v2"
+    });
     if (this.vector && config.semanticRecall) {
       let indexName;
       await Promise.all(
@@ -304,6 +312,7 @@ var Memory = class extends MastraMemory {
         })
       );
     }
+    if (format === `v1`) return new MessageList().add(await result, "memory").get.all.v1();
     return result;
   }
   updateMessageToHideWorkingMemory(message) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/memory",
-  "version": "0.10.2-alpha.1",
+  "version": "0.10.2",
   "description": "",
   "type": "module",
   "main": "./dist/index.js",
@@ -52,11 +52,11 @@
     "typescript": "^5.8.2",
     "typescript-eslint": "^8.26.1",
     "vitest": "^3.1.2",
-    "@internal/lint": "0.0.7",
-    "@mastra/core": "0.10.2-alpha.2"
+    "@internal/lint": "0.0.8",
+    "@mastra/core": "0.10.2"
   },
   "peerDependencies": {
-    "@mastra/core": "^0.10.1-alpha.0"
+    "@mastra/core": "^0.10.2-alpha.0"
   },
   "scripts": {
     "check": "tsc --noEmit",

package/src/index.ts

@@ -6,7 +6,7 @@ import { MastraMemory } from '@mastra/core/memory';
 import type { MemoryConfig, SharedMemoryConfig, StorageThreadType } from '@mastra/core/memory';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
 import { embedMany } from 'ai';
-import type { TextPart, UIMessage } from 'ai';
+import type { CoreMessage, TextPart, UIMessage } from 'ai';
 
 import xxhash from 'xxhash-wasm';
 import { updateWorkingMemoryTool } from './tools/working-memory';
@@ -56,7 +56,7 @@ export class Memory extends MastraMemory {
     threadConfig,
   }: StorageGetMessagesArg & {
     threadConfig?: MemoryConfig;
-  }): Promise<{ messages: MastraMessageV1[]; uiMessages: UIMessage[] }> {
+  }): Promise<{ messages: CoreMessage[]; uiMessages: UIMessage[]; messagesV2: MastraMessageV2[] }> {
     if (resourceId) await this.validateThreadIsOwnedByResource(threadId, resourceId);
 
     const vectorResults: {
@@ -117,6 +117,7 @@ export class Memory extends MastraMemory {
     // Get raw messages from storage
     const rawMessages = await this.storage.getMessages({
       threadId,
+      format: 'v2',
       selectBy: {
         ...selectBy,
         ...(vectorResults?.length
@@ -138,9 +139,7 @@ export class Memory extends MastraMemory {
       threadConfig: config,
     });
 
-    const orderedByDate = rawMessages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-
-    const list = new MessageList({ threadId, resourceId }).add(orderedByDate, 'memory');
+    const list = new MessageList({ threadId, resourceId }).add(rawMessages, 'memory');
     return {
       get messages() {
         // returning v1 messages for backwards compat! v1 messages were CoreMessages stored in the db.
@@ -152,13 +151,18 @@ export class Memory extends MastraMemory {
         if (selectBy?.last && v1Messages.length > selectBy.last) {
           // ex: 23 (v1 messages) minus 20 (selectBy.last messages)
           // means we will start from index 3 and keep all the later newer messages from index 3 til the end of the array
-          return v1Messages.slice(v1Messages.length - selectBy.last);
+          return v1Messages.slice(v1Messages.length - selectBy.last) as CoreMessage[];
         }
-        return v1Messages;
+        // TODO: this is absolutely wrong but became apparent that this is what we were doing before adding MessageList. Our public types said CoreMessage but we were returning MessageType which is equivalent to MastraMessageV1
+        // In a breaking change we should make this the type it actually is.
+        return v1Messages as CoreMessage[];
       },
       get uiMessages() {
         return list.get.all.ui();
       },
+      get messagesV2() {
+        return list.get.all.v2();
+      },
     };
   }
 
@@ -190,12 +194,13 @@ export class Memory extends MastraMemory {
         vectorSearchString: threadConfig.semanticRecall && vectorMessageSearch ? vectorMessageSearch : undefined,
       },
       threadConfig: config,
+      format: 'v2',
     });
     // Using MessageList here just to convert mixed input messages to single type output messages
-    const list = new MessageList({ threadId, resourceId }).add(messagesResult.messages, 'memory');
+    const list = new MessageList({ threadId, resourceId }).add(messagesResult.messagesV2, 'memory');
 
     this.logger.debug(`Remembered message history includes ${messagesResult.messages.length} messages.`);
-    return { messages: list.get.all.v1(), messagesV2: list.get.all.mastra() };
+    return { messages: list.get.all.v1(), messagesV2: list.get.all.v2() };
   }
 
   async getThreadById({ threadId }: { threadId: string }): Promise<StorageThreadType | null> {
@@ -326,13 +331,25 @@ export class Memory extends MastraMemory {
     return result;
   }
 
+  async saveMessages(args: {
+    messages: (MastraMessageV1 | MastraMessageV2)[] | MastraMessageV1[] | MastraMessageV2[];
+    memoryConfig?: MemoryConfig | undefined;
+    format?: 'v1';
+  }): Promise<MastraMessageV1[]>;
+  async saveMessages(args: {
+    messages: (MastraMessageV1 | MastraMessageV2)[] | MastraMessageV1[] | MastraMessageV2[];
+    memoryConfig?: MemoryConfig | undefined;
+    format: 'v2';
+  }): Promise<MastraMessageV2[]>;
   async saveMessages({
     messages,
     memoryConfig,
+    format = `v1`,
   }: {
     messages: (MastraMessageV1 | MastraMessageV2)[];
-    memoryConfig?: MemoryConfig;
-  }): Promise<MastraMessageV2[]> {
+    memoryConfig?: MemoryConfig | undefined;
+    format?: 'v1' | 'v2';
+  }): Promise<MastraMessageV2[] | MastraMessageV1[]> {
     // Then strip working memory tags from all messages
     const updatedMessages = messages
       .map(m => {
@@ -347,7 +364,10 @@ export class Memory extends MastraMemory {
 
     const config = this.getMergedThreadConfig(memoryConfig);
 
-    const result = this.storage.saveMessages({ messages: updatedMessages });
+    const result = this.storage.saveMessages({
+      messages: new MessageList().add(updatedMessages, 'memory').get.all.v2(),
+      format: 'v2',
+    });
 
     if (this.vector && config.semanticRecall) {
       let indexName: Promise<string>;
@@ -412,6 +432,7 @@ export class Memory extends MastraMemory {
       );
     }
 
+    if (format === `v1`) return new MessageList().add(await result, 'memory').get.all.v1(); // for backwards compat convert to v1 message format
     return result;
   }
   protected updateMessageToHideWorkingMemory(message: MastraMessageV1): MastraMessageV1 | null {

package/src/processors/index.test.ts

@@ -1,7 +1,8 @@
 import { openai } from '@ai-sdk/openai';
 import { createTool } from '@mastra/core';
-import type { MessageType } from '@mastra/core';
+import type { MastraMessageV1 } from '@mastra/core';
 import { Agent } from '@mastra/core/agent';
+import type { CoreMessage } from 'ai';
 import cl100k_base from 'js-tiktoken/ranks/cl100k_base';
 import { describe, it, expect, vi } from 'vitest';
 import { z } from 'zod';
@@ -13,7 +14,7 @@ vi.setConfig({ testTimeout: 20_000, hookTimeout: 20_000 });
 describe('TokenLimiter', () => {
   it('should limit messages to the specified token count', () => {
     // Create messages with predictable token counts (approximately 25 tokens each)
-    const { messages } = generateConversationHistory({
+    const { fakeCore } = generateConversationHistory({
       threadId: '1',
       messageCount: 5,
       toolNames: [],
@@ -21,8 +22,7 @@ describe('TokenLimiter', () => {
     });
 
     const limiter = new TokenLimiter(200);
-    // @ts-ignore
-    const result = limiter.process(messages);
+    const result = limiter.process(fakeCore) as MastraMessageV1[];
 
     // Should prioritize newest messages (higher ids)
     expect(result.length).toBe(2);
@@ -37,7 +37,7 @@ describe('TokenLimiter', () => {
   });
 
   it('should use different encodings based on configuration', () => {
-    const { messages } = generateConversationHistory({
+    const { fakeCore } = generateConversationHistory({
       threadId: '6',
       messageCount: 1,
       toolNames: [],
@@ -51,16 +51,16 @@ describe('TokenLimiter', () => {
       encoding: cl100k_base,
     });
 
-    // All should process messages successfully but potentially with different token counts
-    const defaultResult = defaultLimiter.process(messages);
-    const customResult = customLimiter.process(messages);
+    // All should process fakeCore successfully but potentially with different token counts
+    const defaultResult = defaultLimiter.process(fakeCore);
+    const customResult = customLimiter.process(fakeCore);
 
-    // Each should return the same messages but with potentially different token counts
-    expect(defaultResult.length).toBe(messages.length);
-    expect(customResult.length).toBe(messages.length);
+    // Each should return the same fakeCore but with potentially different token counts
+    expect(defaultResult.length).toBe(fakeCore.length);
+    expect(customResult.length).toBe(fakeCore.length);
   });
 
-  function estimateTokens(messages: MessageType[]) {
+  function estimateTokens(messages: MastraMessageV1[]) {
     // Create a TokenLimiter just for counting tokens
     const testLimiter = new TokenLimiter(Infinity);
 
@@ -69,7 +69,7 @@ describe('TokenLimiter', () => {
     // Count tokens for each message including all overheads
     for (const message of messages) {
       // Base token count from the countTokens method
-      estimatedTokens += testLimiter.countTokens(message);
+      estimatedTokens += testLimiter.countTokens(message as CoreMessage); // TODO: this is really actually a MastraMessageV1 but in previous implementations we were casting V1 to CoreMessage which is almost the same but not exactly
     }
 
     return Number(estimatedTokens.toFixed(2));
@@ -82,10 +82,10 @@ describe('TokenLimiter', () => {
   }
 
   async function expectTokenEstimate(config: Parameters<typeof generateConversationHistory>[0], agent: Agent) {
-    const { messages, counts } = generateConversationHistory(config);
+    const { messages, fakeCore, counts } = generateConversationHistory(config);
 
     const estimate = estimateTokens(messages);
-    const used = (await agent.generate(messages.slice(0, -1))).usage.totalTokens;
+    const used = (await agent.generate(fakeCore.slice(0, -1))).usage.totalTokens;
 
     console.log(`Estimated ${estimate} tokens, used ${used} tokens.\n`, counts);
 
@@ -193,13 +193,13 @@ describe('TokenLimiter', () => {
 
 describe.concurrent('ToolCallFilter', () => {
   it('should exclude all tool calls when created with no arguments', () => {
-    const { messages } = generateConversationHistory({
+    const { fakeCore } = generateConversationHistory({
       threadId: '3',
       toolNames: ['weather', 'calculator', 'search'],
       messageCount: 1,
     });
     const filter = new ToolCallFilter();
-    const result = filter.process(messages) as MessageType[];
+    const result = filter.process(fakeCore) as MastraMessageV1[];
 
     // Should only keep the text message and assistant res
     expect(result.length).toBe(2);
@@ -207,13 +207,13 @@ describe.concurrent('ToolCallFilter', () => {
   });
 
   it('should exclude specific tool calls by name', () => {
-    const { messages } = generateConversationHistory({
+    const { fakeCore } = generateConversationHistory({
       threadId: '4',
       toolNames: ['weather', 'calculator'],
       messageCount: 2,
     });
     const filter = new ToolCallFilter({ exclude: ['weather'] });
-    const result = filter.process(messages);
+    const result = filter.process(fakeCore) as MastraMessageV1[];
 
     // Should keep text message, assistant reply, calculator tool call, and calculator result
     expect(result.length).toBe(4);
@@ -224,15 +224,15 @@ describe.concurrent('ToolCallFilter', () => {
   });
 
   it('should keep all messages when exclude list is empty', () => {
-    const { messages } = generateConversationHistory({
+    const { fakeCore } = generateConversationHistory({
       threadId: '5',
       toolNames: ['weather', 'calculator'],
     });
 
     const filter = new ToolCallFilter({ exclude: [] });
-    const result = filter.process(messages);
+    const result = filter.process(fakeCore);
 
     // Should keep all messages
-    expect(result.length).toBe(messages.length);
+    expect(result.length).toBe(fakeCore.length);
   });
 });