@mastra/memory 0.10.1 → 0.10.2-alpha.1

package/.turbo/turbo-build.log

@@ -1,29 +1,12 @@
 
-> @mastra/memory@0.10.1-alpha.0 build /home/runner/work/mastra/mastra/packages/memory
-> pnpm run check && tsup src/index.ts src/processors/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
+> @mastra/memory@0.10.2-alpha.1 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.1-alpha.0 check /home/runner/work/mastra/mastra/packages/memory
+> @mastra/memory@0.10.2-alpha.1 check /home/runner/work/mastra/mastra/packages/memory
 > tsc --noEmit
 
-CLI Building entry: src/index.ts, src/processors/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.4.0
-TSC Build start
-TSC ⚡️ Build success in 9843ms
-DTS Build start
-CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/packages/memory/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/packages/memory/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 11521ms
-CLI Cleaning output folder
-ESM Build start
-CJS Build start
-ESM dist/index.js            18.51 KB
-ESM dist/processors/index.js 5.38 KB
-ESM ⚡️ Build success in 984ms
-CJS dist/processors/index.cjs 5.59 KB
-CJS dist/index.cjs            18.70 KB
-CJS ⚡️ Build success in 984ms

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @mastra/memory
 
+## 0.10.2-alpha.1
+
+### Patch Changes
+
+- f0d559f: Fix peerdeps for alpha channel
+- Updated dependencies [1e8bb40]
+  - @mastra/core@0.10.2-alpha.2
+
+## 0.10.2-alpha.0
+
+### Patch Changes
+
+- e5dc18d: Added a backwards compatible layer to begin storing/retrieving UIMessages in storage instead of CoreMessages
+- Updated dependencies [592a2db]
+- Updated dependencies [e5dc18d]
+  - @mastra/core@0.10.2-alpha.0
+
 ## 0.10.1
 
 ### Patch Changes

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

@@ -1,16 +1,17 @@
-import type { AiMessageType } from '@mastra/core';
 import type { CoreMessage } from '@mastra/core';
 import type { CoreTool } from '@mastra/core';
 import { MastraMemory } from '@mastra/core/memory';
+import type { MastraMessageV1 } from '@mastra/core';
+import type { MastraMessageV2 } from '@mastra/core/agent';
 import type { MemoryConfig } from '@mastra/core/memory';
 import { MemoryProcessor } from '@mastra/core/memory';
 import { MemoryProcessor as MemoryProcessor_2 } from '@mastra/core';
 import type { MemoryProcessorOpts } from '@mastra/core';
-import type { MessageType } from '@mastra/core/memory';
 import type { SharedMemoryConfig } from '@mastra/core/memory';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
 import type { TiktokenBPE } from 'js-tiktoken/lite';
+import type { UIMessage } from 'ai';
 
 /**
  * Concrete implementation of MastraMemory that adds support for thread configuration
@@ -22,8 +23,8 @@ export declare class Memory extends MastraMemory {
     query({ threadId, resourceId, selectBy, threadConfig, }: StorageGetMessagesArg & {
         threadConfig?: MemoryConfig;
     }): Promise<{
-        messages: CoreMessage[];
-        uiMessages: AiMessageType[];
+        messages: MastraMessageV1[];
+        uiMessages: UIMessage[];
     }>;
     rememberMessages({ threadId, resourceId, vectorMessageSearch, config, }: {
         threadId: string;
@@ -31,9 +32,8 @@ export declare class Memory extends MastraMemory {
         vectorMessageSearch?: string;
         config?: MemoryConfig;
     }): Promise<{
-        threadId: string;
-        messages: CoreMessage[];
-        uiMessages: AiMessageType[];
+        messages: MastraMessageV1[];
+        messagesV2: MastraMessageV2[];
     }>;
     getThreadById({ threadId }: {
         threadId: string;
@@ -57,31 +57,24 @@ export declare class Memory extends MastraMemory {
     private firstEmbed;
     private embedMessageContent;
     saveMessages({ messages, memoryConfig, }: {
-        messages: MessageType[];
+        messages: (MastraMessageV1 | MastraMessageV2)[];
         memoryConfig?: MemoryConfig;
-    }): Promise<MessageType[]>;
-    protected updateMessagesToHideWorkingMemory(messages: MessageType[]): MessageType[];
+    }): Promise<MastraMessageV2[]>;
+    protected updateMessageToHideWorkingMemory(message: MastraMessageV1): MastraMessageV1 | null;
+    protected updateMessageToHideWorkingMemoryV2(message: MastraMessageV2): MastraMessageV2 | null;
     protected parseWorkingMemory(text: string): string | null;
     getWorkingMemory({ threadId }: {
         threadId: string;
     }): Promise<string | null>;
-    private saveWorkingMemory;
     getSystemMessage({ threadId, memoryConfig, }: {
         threadId: string;
         memoryConfig?: MemoryConfig;
     }): Promise<string | null>;
     defaultWorkingMemoryTemplate: string;
-    private getWorkingMemoryWithInstruction;
     private getWorkingMemoryToolInstruction;
     getTools(config?: MemoryConfig): Record<string, CoreTool>;
 }
 
-/**
- * Self-heals message ordering to ensure tool calls are directly before their matching tool results.
- * This is needed due to a bug where messages were saved in the wrong order. That bug is fixed, but this code ensures any tool calls saved in the wrong order in the past will still be usable now.
- */
-export declare function reorderToolCallsAndResults(messages: MessageType[]): MessageType[];
-
 /**
  * Limits the total number of tokens in the messages.
  * Uses js-tiktoken with o200k_base encoding by default for accurate token counting with modern models.

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

@@ -1,16 +1,17 @@
-import type { AiMessageType } from '@mastra/core';
 import type { CoreMessage } from '@mastra/core';
 import type { CoreTool } from '@mastra/core';
 import { MastraMemory } from '@mastra/core/memory';
+import type { MastraMessageV1 } from '@mastra/core';
+import type { MastraMessageV2 } from '@mastra/core/agent';
 import type { MemoryConfig } from '@mastra/core/memory';
 import { MemoryProcessor } from '@mastra/core/memory';
 import { MemoryProcessor as MemoryProcessor_2 } from '@mastra/core';
 import type { MemoryProcessorOpts } from '@mastra/core';
-import type { MessageType } from '@mastra/core/memory';
 import type { SharedMemoryConfig } from '@mastra/core/memory';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
 import type { TiktokenBPE } from 'js-tiktoken/lite';
+import type { UIMessage } from 'ai';
 
 /**
  * Concrete implementation of MastraMemory that adds support for thread configuration
@@ -22,8 +23,8 @@ export declare class Memory extends MastraMemory {
     query({ threadId, resourceId, selectBy, threadConfig, }: StorageGetMessagesArg & {
         threadConfig?: MemoryConfig;
     }): Promise<{
-        messages: CoreMessage[];
-        uiMessages: AiMessageType[];
+        messages: MastraMessageV1[];
+        uiMessages: UIMessage[];
     }>;
     rememberMessages({ threadId, resourceId, vectorMessageSearch, config, }: {
         threadId: string;
@@ -31,9 +32,8 @@ export declare class Memory extends MastraMemory {
         vectorMessageSearch?: string;
         config?: MemoryConfig;
     }): Promise<{
-        threadId: string;
-        messages: CoreMessage[];
-        uiMessages: AiMessageType[];
+        messages: MastraMessageV1[];
+        messagesV2: MastraMessageV2[];
     }>;
     getThreadById({ threadId }: {
         threadId: string;
@@ -57,31 +57,24 @@ export declare class Memory extends MastraMemory {
     private firstEmbed;
     private embedMessageContent;
     saveMessages({ messages, memoryConfig, }: {
-        messages: MessageType[];
+        messages: (MastraMessageV1 | MastraMessageV2)[];
         memoryConfig?: MemoryConfig;
-    }): Promise<MessageType[]>;
-    protected updateMessagesToHideWorkingMemory(messages: MessageType[]): MessageType[];
+    }): Promise<MastraMessageV2[]>;
+    protected updateMessageToHideWorkingMemory(message: MastraMessageV1): MastraMessageV1 | null;
+    protected updateMessageToHideWorkingMemoryV2(message: MastraMessageV2): MastraMessageV2 | null;
     protected parseWorkingMemory(text: string): string | null;
     getWorkingMemory({ threadId }: {
         threadId: string;
     }): Promise<string | null>;
-    private saveWorkingMemory;
     getSystemMessage({ threadId, memoryConfig, }: {
         threadId: string;
         memoryConfig?: MemoryConfig;
     }): Promise<string | null>;
     defaultWorkingMemoryTemplate: string;
-    private getWorkingMemoryWithInstruction;
     private getWorkingMemoryToolInstruction;
     getTools(config?: MemoryConfig): Record<string, CoreTool>;
 }
 
-/**
- * Self-heals message ordering to ensure tool calls are directly before their matching tool results.
- * This is needed due to a bug where messages were saved in the wrong order. That bug is fixed, but this code ensures any tool calls saved in the wrong order in the past will still be usable now.
- */
-export declare function reorderToolCallsAndResults(messages: MessageType[]): MessageType[];
-
 /**
  * Limits the total number of tokens in the messages.
  * Uses js-tiktoken with o200k_base encoding by default for accurate token counting with modern models.

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var core = require('@mastra/core');
+var agent = require('@mastra/core/agent');
 var memory = require('@mastra/core/memory');
 var ai = require('ai');
 var xxhash = require('xxhash-wasm');
@@ -38,48 +39,6 @@ var updateWorkingMemoryTool = {
   }
 };
 
-// src/utils/index.ts
-var isToolCallWithId = (message, targetToolCallId) => {
-  if (!message || !Array.isArray(message.content)) return false;
-  return message.content.some(
-    (part) => part && typeof part === "object" && "type" in part && part.type === "tool-call" && "toolCallId" in part && part.toolCallId === targetToolCallId
-  );
-};
-var getToolResultIndexById = (id, results) => results.findIndex((message) => {
-  if (!Array.isArray(message?.content)) return false;
-  return message.content.some(
-    (part) => part && typeof part === "object" && "type" in part && part.type === "tool-result" && "toolCallId" in part && part.toolCallId === id
-  );
-});
-function reorderToolCallsAndResults(messages) {
-  if (!messages.length) return messages;
-  const results = [...messages];
-  const toolCallIds = /* @__PURE__ */ new Set();
-  for (const message of results) {
-    if (!Array.isArray(message.content)) continue;
-    for (const part of message.content) {
-      if (part && typeof part === "object" && "type" in part && part.type === "tool-result" && "toolCallId" in part && part.toolCallId) {
-        toolCallIds.add(part.toolCallId);
-      }
-    }
-  }
-  for (const toolCallId of toolCallIds) {
-    const resultIndex = getToolResultIndexById(toolCallId, results);
-    const oneMessagePrev = results[resultIndex - 1];
-    if (isToolCallWithId(oneMessagePrev, toolCallId)) {
-      continue;
-    }
-    const toolCallIndex = results.findIndex((message) => isToolCallWithId(message, toolCallId));
-    if (toolCallIndex !== -1 && toolCallIndex !== resultIndex - 1) {
-      const toolCall = results[toolCallIndex];
-      if (!toolCall) continue;
-      results.splice(toolCallIndex, 1);
-      results.splice(getToolResultIndexById(toolCallId, results), 0, toolCall);
-    }
-  }
-  return results;
-}
-
 // src/index.ts
 var CHARS_PER_TOKEN = 4;
 var DEFAULT_MESSAGE_RANGE = { before: 2, after: 2 };
@@ -170,10 +129,19 @@ 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 reorderedToolCalls = reorderToolCallsAndResults(orderedByDate);
-    const messages = this.parseMessages(reorderedToolCalls);
-    const uiMessages = this.convertToUIMessages(reorderedToolCalls);
-    return { messages, uiMessages };
+    const list = new agent.MessageList({ threadId, resourceId }).add(orderedByDate, "memory");
+    return {
+      get messages() {
+        const v1Messages = list.get.all.v1();
+        if (selectBy?.last && v1Messages.length > selectBy.last) {
+          return v1Messages.slice(v1Messages.length - selectBy.last);
+        }
+        return v1Messages;
+      },
+      get uiMessages() {
+        return list.get.all.ui();
+      }
+    };
   }
   async rememberMessages({
     threadId,
@@ -186,8 +154,7 @@ var Memory = class extends memory.MastraMemory {
     if (!threadConfig.lastMessages && !threadConfig.semanticRecall) {
       return {
         messages: [],
-        uiMessages: [],
-        threadId
+        messagesV2: []
       };
     }
     const messagesResult = await this.query({
@@ -198,12 +165,9 @@ var Memory = class extends memory.MastraMemory {
       },
       threadConfig: config
     });
+    const list = new agent.MessageList({ threadId, resourceId }).add(messagesResult.messages, "memory");
     this.logger.debug(`Remembered message history includes ${messagesResult.messages.length} messages.`);
-    return {
-      threadId,
-      messages: messagesResult.messages,
-      uiMessages: messagesResult.uiMessages
-    };
+    return { messages: list.get.all.v1(), messagesV2: list.get.all.mastra() };
   }
   async getThreadById({ threadId }) {
     return this.storage.getThreadById({ threadId });
@@ -295,8 +259,13 @@ var Memory = class extends memory.MastraMemory {
     messages,
     memoryConfig
   }) {
-    await this.saveWorkingMemory(messages);
-    const updatedMessages = this.updateMessagesToHideWorkingMemory(messages);
+    const updatedMessages = messages.map((m) => {
+      if (agent.MessageList.isMastraMessageV1(m)) {
+        return this.updateMessageToHideWorkingMemory(m);
+      }
+      if (!m.type) m.type = `v2`;
+      return this.updateMessageToHideWorkingMemoryV2(m);
+    }).filter((m) => Boolean(m));
     const config = this.getMergedThreadConfig(memoryConfig);
     const result = this.storage.saveMessages({ messages: updatedMessages });
     if (this.vector && config.semanticRecall) {
@@ -304,11 +273,20 @@ var Memory = class extends memory.MastraMemory {
       await Promise.all(
         updatedMessages.map(async (message) => {
           let textForEmbedding = null;
-          if (typeof message.content === "string" && message.content.trim() !== "") {
-            textForEmbedding = message.content;
-          } else if (Array.isArray(message.content)) {
-            const joined = message.content.filter((part) => part && part.type === "text" && typeof part.text === "string").map((part) => part.text).join(" ").trim();
-            if (joined) textForEmbedding = joined;
+          if (agent.MessageList.isMastraMessageV2(message)) {
+            if (message.content.content && typeof message.content.content === "string" && message.content.content.trim() !== "") {
+              textForEmbedding = message.content.content;
+            } else if (message.content.parts && message.content.parts.length > 0) {
+              const joined = message.content.parts.filter((part) => part.type === "text").map((part) => part.text).join(" ").trim();
+              if (joined) textForEmbedding = joined;
+            }
+          } else if (agent.MessageList.isMastraMessageV1(message)) {
+            if (message.content && typeof message.content === "string" && message.content.trim() !== "") {
+              textForEmbedding = message.content;
+            } else if (message.content && Array.isArray(message.content) && message.content.length > 0) {
+              const joined = message.content.filter((part) => part.type === "text").map((part) => part.text).join(" ").trim();
+              if (joined) textForEmbedding = joined;
+            }
           }
           if (!textForEmbedding) return;
           const { embeddings, chunks, dimension } = await this.embedMessageContent(textForEmbedding);
@@ -334,37 +312,58 @@ var Memory = class extends memory.MastraMemory {
     }
     return result;
   }
-  updateMessagesToHideWorkingMemory(messages) {
+  updateMessageToHideWorkingMemory(message) {
     const workingMemoryRegex = /<working_memory>([^]*?)<\/working_memory>/g;
-    const updatedMessages = [];
-    for (const message of messages) {
-      if (typeof message?.content === `string`) {
-        updatedMessages.push({
-          ...message,
-          content: message.content.replace(workingMemoryRegex, ``).trim()
-        });
-      } else if (Array.isArray(message?.content)) {
-        const filteredContent = message.content.filter(
-          (content) => !((content.type === "tool-call" || content.type === "tool-result") && content.toolName === "updateWorkingMemory")
-        );
-        if (filteredContent.length === 0) {
-          continue;
+    if (typeof message?.content === `string`) {
+      return {
+        ...message,
+        content: message.content.replace(workingMemoryRegex, ``).trim()
+      };
+    } else if (Array.isArray(message?.content)) {
+      const filteredContent = message.content.filter(
+        (content) => content.type !== "tool-call" && content.type !== "tool-result" || content.toolName !== "updateWorkingMemory"
+      );
+      const newContent = filteredContent.map((content) => {
+        if (content.type === "text") {
+          return {
+            ...content,
+            text: content.text.replace(workingMemoryRegex, "").trim()
+          };
         }
-        const newContent = filteredContent.map((content) => {
-          if (content.type === "text") {
-            return {
-              ...content,
-              text: content.text.replace(workingMemoryRegex, "").trim()
-            };
-          }
-          return { ...content };
-        });
-        updatedMessages.push({ ...message, content: newContent });
-      } else {
-        updatedMessages.push({ ...message });
+        return { ...content };
+      });
+      if (!newContent.length) return null;
+      return { ...message, content: newContent };
+    } else {
+      return { ...message };
+    }
+  }
+  updateMessageToHideWorkingMemoryV2(message) {
+    const workingMemoryRegex = /<working_memory>([^]*?)<\/working_memory>/g;
+    const newMessage = { ...message, content: { ...message.content } };
+    if (newMessage.content.content && typeof newMessage.content.content === "string") {
+      newMessage.content.content = newMessage.content.content.replace(workingMemoryRegex, "").trim();
+    }
+    if (newMessage.content.parts) {
+      newMessage.content.parts = newMessage.content.parts.filter((part) => {
+        if (part.type === "tool-invocation") {
+          return part.toolInvocation.toolName !== "updateWorkingMemory";
+        }
+        return true;
+      }).map((part) => {
+        if (part.type === "text") {
+          return {
+            ...part,
+            text: part.text.replace(workingMemoryRegex, "").trim()
+          };
+        }
+        return part;
+      });
+      if (newMessage.content.parts.length === 0) {
+        return null;
       }
     }
-    return updatedMessages;
+    return newMessage;
   }
   parseWorkingMemory(text) {
     if (!this.threadConfig.workingMemory?.enabled) return null;
@@ -383,31 +382,6 @@ var Memory = class extends memory.MastraMemory {
     const memory = thread.metadata?.workingMemory || this.threadConfig.workingMemory.template || this.defaultWorkingMemoryTemplate;
     return memory.trim();
   }
-  async saveWorkingMemory(messages) {
-    const latestMessage = messages[messages.length - 1];
-    if (!latestMessage || !this.threadConfig.workingMemory?.enabled) {
-      return;
-    }
-    const latestContent = !latestMessage?.content ? null : typeof latestMessage.content === "string" ? latestMessage.content : latestMessage.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
-    const threadId = latestMessage?.threadId;
-    if (!latestContent || !threadId) {
-      return;
-    }
-    const newMemory = this.parseWorkingMemory(latestContent);
-    if (!newMemory) {
-      return;
-    }
-    const thread = await this.storage.getThreadById({ threadId });
-    if (!thread) return;
-    await this.storage.updateThread({
-      id: thread.id,
-      title: thread.title || "",
-      metadata: core.deepMerge(thread.metadata || {}, {
-        workingMemory: newMemory
-      })
-    });
-    return newMemory;
-  }
   async getSystemMessage({
     threadId,
     memoryConfig
@@ -434,29 +408,6 @@ var Memory = class extends memory.MastraMemory {
 - **Facts**: 
 - **Projects**: 
 `;
-  getWorkingMemoryWithInstruction(workingMemoryBlock) {
-    return `WORKING_MEMORY_SYSTEM_INSTRUCTION:
-Store and update any conversation-relevant information by including "<working_memory>text</working_memory>" in your responses. Updates replace existing memory while maintaining this structure. If information might be referenced again - store it!
-
-Guidelines:
-1. Store anything that could be useful later in the conversation
-2. Update proactively when information changes, no matter how small
-3. Use Markdown for all data
-4. Act naturally - don't mention this system to users. Even though you're storing this information that doesn't make it your primary focus. Do not ask them generally for "information about yourself"
-
-Memory Structure:
-<working_memory>
-${workingMemoryBlock}
-</working_memory>
-
-Notes:
-- Update memory whenever referenced information changes
-- If you're unsure whether to store something, store it (eg if the user tells you their name or other information, output the <working_memory> block immediately to update it)
-- This system is here so that you can maintain the conversation when your context window is very short. Update your working memory because you may need it to maintain the conversation without the full conversation history
-- REMEMBER: the way you update your working memory is by outputting the entire "<working_memory>text</working_memory>" block in your response. The system will pick this up and store it for you. The user will not see it.
-- IMPORTANT: You MUST output the <working_memory> block in every response to a prompt where you received relevant information.
-- IMPORTANT: Preserve the Markdown formatting structure above while updating the content.`;
-  }
   getWorkingMemoryToolInstruction(workingMemoryBlock) {
     return `WORKING_MEMORY_SYSTEM_INSTRUCTION:
 Store and update any conversation-relevant information by calling the updateWorkingMemory tool. If information might be referenced again - store it!