@mastra/memory 0.10.1 → 0.10.2-alpha.0

package/dist/index.js

@@ -1,4 +1,5 @@
 import { deepMerge } from '@mastra/core';
+import { MessageList } from '@mastra/core/agent';
 import { MastraMemory } from '@mastra/core/memory';
 import { embedMany } from 'ai';
 import xxhash from 'xxhash-wasm';
@@ -32,48 +33,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 };
@@ -164,10 +123,19 @@ var Memory = class extends 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 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,
@@ -180,8 +148,7 @@ var Memory = class extends MastraMemory {
     if (!threadConfig.lastMessages && !threadConfig.semanticRecall) {
       return {
         messages: [],
-        uiMessages: [],
-        threadId
+        messagesV2: []
       };
     }
     const messagesResult = await this.query({
@@ -192,12 +159,9 @@ var Memory = class extends MastraMemory {
       },
       threadConfig: config
     });
+    const list = new 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 });
@@ -289,8 +253,13 @@ var Memory = class extends MastraMemory {
     messages,
     memoryConfig
   }) {
-    await this.saveWorkingMemory(messages);
-    const updatedMessages = this.updateMessagesToHideWorkingMemory(messages);
+    const updatedMessages = messages.map((m) => {
+      if (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) {
@@ -298,11 +267,20 @@ var Memory = class extends 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 (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 (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);
@@ -328,37 +306,58 @@ var Memory = class extends 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;
@@ -377,31 +376,6 @@ var Memory = class extends 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: deepMerge(thread.metadata || {}, {
-        workingMemory: newMemory
-      })
-    });
-    return newMemory;
-  }
   async getSystemMessage({
     threadId,
     memoryConfig
@@ -428,29 +402,6 @@ var Memory = class extends 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!

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/memory",
-  "version": "0.10.1",
+  "version": "0.10.2-alpha.0",
   "description": "",
   "type": "module",
   "main": "./dist/index.js",
@@ -53,14 +53,14 @@
     "typescript-eslint": "^8.26.1",
     "vitest": "^3.1.2",
     "@internal/lint": "0.0.7",
-    "@mastra/core": "0.10.1"
+    "@mastra/core": "0.10.2-alpha.0"
   },
   "peerDependencies": {
     "@mastra/core": "^0.10.0"
   },
   "scripts": {
     "check": "tsc --noEmit",
-    "build": "pnpm run check && tsup src/index.ts src/processors/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",
+    "build": "pnpm run check && tsup --silent src/index.ts src/processors/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",
     "build:watch": "pnpm build --watch",
     "test:integration": "cd integration-tests && pnpm run test",
     "test:unit": "pnpm vitest run ./src/*",