@mastra/memory 0.15.11 → 1.0.0-beta.1

package/dist/index.js

@@ -27,8 +27,10 @@ var updateWorkingMemoryTool = (memoryConfig) => {
     id: "update-working-memory",
     description: `Update the working memory with new information. Any data not included will be overwritten.${schema ? " Always pass data as string to the memory field. Never pass an object." : ""}`,
     inputSchema,
-    execute: async (params) => {
-      const { context, threadId, memory, resourceId } = params;
+    execute: async (inputData, context) => {
+      const threadId = context?.agent?.threadId;
+      const resourceId = context?.agent?.resourceId;
+      const memory = context?.memory;
       if (!threadId || !memory || !resourceId) {
         throw new Error("Thread ID, Memory instance, and resourceId are required for working memory updates");
       }
@@ -43,7 +45,7 @@ var updateWorkingMemoryTool = (memoryConfig) => {
       if (thread.resourceId && thread.resourceId !== resourceId) {
         throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
       }
-      const workingMemory = typeof context.memory === "string" ? context.memory : JSON.stringify(context.memory);
+      const workingMemory = typeof inputData.memory === "string" ? inputData.memory : JSON.stringify(inputData.memory);
       await memory.updateWorkingMemory({
         threadId,
         resourceId,
@@ -69,8 +71,10 @@ var __experimental_updateWorkingMemoryToolVNext = (config) => {
         "The reason you're updating working memory. Passing any value other than 'append-new-memory' requires a searchString to be provided. Defaults to append-new-memory"
       )
     }),
-    execute: async (params) => {
-      const { context, threadId, memory, resourceId } = params;
+    execute: async (inputData, context) => {
+      const threadId = context?.agent?.threadId;
+      const resourceId = context?.agent?.resourceId;
+      const memory = context?.memory;
       if (!threadId || !memory || !resourceId) {
         throw new Error("Thread ID, Memory instance, and resourceId are required for working memory updates");
       }
@@ -85,25 +89,25 @@ var __experimental_updateWorkingMemoryToolVNext = (config) => {
       if (thread.resourceId && thread.resourceId !== resourceId) {
         throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
       }
-      const workingMemory = context.newMemory || "";
-      if (!context.updateReason) context.updateReason = `append-new-memory`;
-      if (context.searchString && config.workingMemory?.scope === `resource` && context.updateReason === `replace-irrelevant-memory`) {
-        context.searchString = void 0;
+      const workingMemory = inputData.newMemory || "";
+      if (!inputData.updateReason) inputData.updateReason = `append-new-memory`;
+      if (inputData.searchString && config.workingMemory?.scope === `resource` && inputData.updateReason === `replace-irrelevant-memory`) {
+        inputData.searchString = void 0;
       }
-      if (context.updateReason === `append-new-memory` && context.searchString) {
-        context.searchString = void 0;
+      if (inputData.updateReason === `append-new-memory` && inputData.searchString) {
+        inputData.searchString = void 0;
       }
-      if (context.updateReason !== `append-new-memory` && !context.searchString) {
+      if (inputData.updateReason !== `append-new-memory` && !inputData.searchString) {
         return {
           success: false,
-          reason: `updateReason was ${context.updateReason} but no searchString was provided. Unable to replace undefined with "${context.newMemory}"`
+          reason: `updateReason was ${inputData.updateReason} but no searchString was provided. Unable to replace undefined with "${inputData.newMemory}"`
         };
       }
       const result = await memory.__experimental_updateWorkingMemoryVNext({
         threadId,
         resourceId,
         workingMemory,
-        searchString: context.searchString,
+        searchString: inputData.searchString,
         memoryConfig: config
       });
       if (result) {
@@ -116,8 +120,8 @@ var __experimental_updateWorkingMemoryToolVNext = (config) => {
 
 // src/index.ts
 var CHARS_PER_TOKEN = 4;
-var DEFAULT_MESSAGE_RANGE = { before: 2, after: 2 };
-var DEFAULT_TOP_K = 2;
+var DEFAULT_MESSAGE_RANGE = { before: 1, after: 1 };
+var DEFAULT_TOP_K = 4;
 var isZodObject = (v) => v instanceof ZodObject;
 var Memory = class extends MastraMemory {
   constructor(config = {}) {
@@ -134,7 +138,7 @@ var Memory = class extends MastraMemory {
     this.threadConfig = mergedConfig;
   }
   async validateThreadIsOwnedByResource(threadId, resourceId, config) {
-    const resourceScope = typeof config?.semanticRecall === "object" && config?.semanticRecall?.scope === "resource";
+    const resourceScope = typeof config?.semanticRecall === "object" && config?.semanticRecall?.scope !== `thread` || config.semanticRecall === true;
     const thread = await this.storage.getThreadById({ threadId });
     if (!thread && !resourceScope) {
       throw new Error(`No thread found with id ${threadId}`);
@@ -146,7 +150,9 @@ var Memory = class extends MastraMemory {
     }
   }
   checkStorageFeatureSupport(config) {
-    if (typeof config.semanticRecall === `object` && config.semanticRecall.scope === `resource` && !this.storage.supports.selectByIncludeResourceScope) {
+    const resourceScope = typeof config.semanticRecall === "object" && config.semanticRecall.scope !== "thread" || // resource scope is now default
+    config.semanticRecall === true;
+    if (resourceScope && !this.storage.supports.selectByIncludeResourceScope) {
       throw new Error(
         `Memory error: Attached storage adapter "${this.storage.name || "unknown"}" doesn't support semanticRecall: { scope: "resource" } yet and currently only supports per-thread semantic recall.`
       );
@@ -157,18 +163,17 @@ var Memory = class extends MastraMemory {
       );
     }
   }
-  async query({
-    threadId,
-    resourceId,
-    selectBy,
-    threadConfig
-  }) {
+  async recall(args) {
+    const { threadId, resourceId, perPage: perPageArg, page, orderBy, threadConfig, vectorSearchString, filter } = args;
     const config = this.getMergedThreadConfig(threadConfig || {});
     if (resourceId) await this.validateThreadIsOwnedByResource(threadId, resourceId, config);
+    const perPage = perPageArg !== void 0 ? perPageArg : config.lastMessages;
     const vectorResults = [];
-    this.logger.debug(`Memory query() with:`, {
+    this.logger.debug(`Memory recall() with:`, {
       threadId,
-      selectBy,
+      perPage,
+      page,
+      orderBy,
       threadConfig
     });
     this.checkStorageFeatureSupport(config);
@@ -181,9 +186,14 @@ var Memory = class extends MastraMemory {
       topK: config?.semanticRecall?.topK ?? defaultTopK,
       messageRange: config?.semanticRecall?.messageRange ?? defaultRange
     };
-    const resourceScope = typeof config?.semanticRecall === "object" && config?.semanticRecall?.scope === `resource`;
-    if (config?.semanticRecall && selectBy?.vectorSearchString && this.vector) {
-      const { embeddings, dimension } = await this.embedMessageContent(selectBy.vectorSearchString);
+    const resourceScope = typeof config?.semanticRecall === "object" && config?.semanticRecall?.scope !== `thread` || config.semanticRecall === true;
+    if (resourceScope && !resourceId && config?.semanticRecall && vectorSearchString) {
+      throw new Error(
+        `Memory error: Resource-scoped semantic recall is enabled but no resourceId was provided. Either provide a resourceId or explicitly set semanticRecall.scope to 'thread'.`
+      );
+    }
+    if (config?.semanticRecall && vectorSearchString && this.vector) {
+      const { embeddings, dimension } = await this.embedMessageContent(vectorSearchString);
       const { indexName } = await this.createEmbeddingIndex(dimension, config);
       await Promise.all(
         embeddings.map(async (embedding) => {
@@ -207,114 +217,32 @@ var Memory = class extends MastraMemory {
         })
       );
     }
-    let rawMessages;
-    if (selectBy?.pagination) {
-      const paginatedResult = await this.storage.getMessagesPaginated({
-        threadId,
-        resourceId,
-        format: "v2",
-        selectBy: {
-          ...selectBy,
-          ...vectorResults?.length ? {
-            include: vectorResults.map((r) => ({
-              id: r.metadata?.message_id,
-              threadId: r.metadata?.thread_id,
-              withNextMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.after,
-              withPreviousMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.before
-            }))
-          } : {}
-        },
-        threadConfig: config
-      });
-      rawMessages = paginatedResult.messages;
-    } else {
-      rawMessages = await this.storage.getMessages({
-        threadId,
-        resourceId,
-        format: "v2",
-        selectBy: {
-          ...selectBy,
-          ...vectorResults?.length ? {
-            include: vectorResults.map((r) => ({
-              id: r.metadata?.message_id,
-              threadId: r.metadata?.thread_id,
-              withNextMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.after,
-              withPreviousMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.before
-            }))
-          } : {}
-        },
-        threadConfig: config
-      });
-    }
-    const list = new MessageList({ threadId, resourceId }).add(rawMessages, "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();
-      },
-      get messagesV2() {
-        return list.get.all.v2();
-      }
-    };
-  }
-  async rememberMessages({
-    threadId,
-    resourceId,
-    vectorMessageSearch,
-    config
-  }) {
-    const threadConfig = this.getMergedThreadConfig(config || {});
-    if (resourceId) await this.validateThreadIsOwnedByResource(threadId, resourceId, threadConfig);
-    if (!threadConfig.lastMessages && !threadConfig.semanticRecall) {
-      return {
-        messages: [],
-        messagesV2: []
-      };
-    }
-    const messagesResult = await this.query({
-      resourceId,
+    const paginatedResult = await this.storage.listMessages({
       threadId,
-      selectBy: {
-        last: threadConfig.lastMessages,
-        vectorSearchString: threadConfig.semanticRecall && vectorMessageSearch ? vectorMessageSearch : void 0
-      },
-      threadConfig: config,
-      format: "v2"
+      resourceId,
+      perPage,
+      page,
+      orderBy,
+      filter,
+      ...vectorResults?.length ? {
+        include: vectorResults.map((r) => ({
+          id: r.metadata?.message_id,
+          threadId: r.metadata?.thread_id,
+          withNextMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.after,
+          withPreviousMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.before
+        }))
+      } : {}
     });
-    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.v2() };
+    const rawMessages = paginatedResult.messages;
+    const list = new MessageList({ threadId, resourceId }).add(rawMessages, "memory");
+    const messages = list.get.all.db();
+    return { messages };
   }
   async getThreadById({ threadId }) {
     return this.storage.getThreadById({ threadId });
   }
-  async getThreadsByResourceId({
-    resourceId,
-    orderBy,
-    sortDirection
-  }) {
-    return this.storage.getThreadsByResourceId({ resourceId, orderBy, sortDirection });
-  }
-  async getThreadsByResourceIdPaginated({
-    resourceId,
-    page,
-    perPage,
-    orderBy,
-    sortDirection
-  }) {
-    return this.storage.getThreadsByResourceIdPaginated({
-      resourceId,
-      page,
-      perPage,
-      orderBy,
-      sortDirection
-    });
+  async listThreadsByResourceId(args) {
+    return this.storage.listThreadsByResourceId(args);
   }
   async handleWorkingMemoryFromMetadata({
     workingMemory,
@@ -324,7 +252,7 @@ var Memory = class extends MastraMemory {
     const config = this.getMergedThreadConfig(memoryConfig || {});
     if (config.workingMemory?.enabled) {
       this.checkStorageFeatureSupport(config);
-      const scope = config.workingMemory.scope || "thread";
+      const scope = config.workingMemory.scope || "resource";
       if (scope === "resource" && resourceId) {
         await this.storage.updateResource({
           resourceId,
@@ -381,7 +309,12 @@ var Memory = class extends MastraMemory {
       throw new Error("Working memory is not enabled for this memory instance");
     }
     this.checkStorageFeatureSupport(config);
-    const scope = config.workingMemory.scope || "thread";
+    const scope = config.workingMemory.scope || "resource";
+    if (scope === "resource" && !resourceId) {
+      throw new Error(
+        `Memory error: Resource-scoped working memory is enabled but no resourceId was provided. Either provide a resourceId or explicitly set workingMemory.scope to 'thread'.`
+      );
+    }
     if (scope === "resource" && resourceId) {
       await this.storage.updateResource({
         resourceId,
@@ -453,7 +386,12 @@ ${workingMemory}`;
         reason = `started new working memory`;
       }
       workingMemory = template?.content ? workingMemory.replaceAll(template?.content, "") : workingMemory;
-      const scope = config.workingMemory.scope || "thread";
+      const scope = config.workingMemory.scope || "resource";
+      if (scope === "resource" && !resourceId) {
+        throw new Error(
+          `Memory error: Resource-scoped working memory is enabled but no resourceId was provided. Either provide a resourceId or explicitly set workingMemory.scope to 'thread'.`
+        );
+      }
       if (scope === "resource" && resourceId) {
         await this.storage.updateResource({
           resourceId,
@@ -537,40 +475,28 @@ ${workingMemory}`;
   }
   async saveMessages({
     messages,
-    memoryConfig,
-    format = `v1`
+    memoryConfig
   }) {
     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: new MessageList().add(updatedMessages, "memory").get.all.v2(),
-      format: "v2"
+    const dbMessages = new MessageList({
+      generateMessageId: () => this.generateId()
+    }).add(updatedMessages, "memory").get.all.db();
+    const result = await this.storage.saveMessages({
+      messages: dbMessages
     });
     if (this.vector && config.semanticRecall) {
       let indexName;
       await Promise.all(
         updatedMessages.map(async (message) => {
           let textForEmbedding = null;
-          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 (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;
           }
           if (!textForEmbedding) return;
           const { embeddings, chunks, dimension } = await this.embedMessageContent(textForEmbedding);
@@ -594,7 +520,6 @@ ${workingMemory}`;
         })
       );
     }
-    if (format === `v1`) return new MessageList().add(await result, "memory").get.all.v1();
     return result;
   }
   updateMessageToHideWorkingMemory(message) {
@@ -670,8 +595,13 @@ ${workingMemory}`;
       return null;
     }
     this.checkStorageFeatureSupport(config);
-    const scope = config.workingMemory.scope || "thread";
+    const scope = config.workingMemory.scope || "resource";
     let workingMemoryData = null;
+    if (scope === "resource" && !resourceId) {
+      throw new Error(
+        `Memory error: Resource-scoped working memory is enabled but no resourceId was provided. Either provide a resourceId or explicitly set workingMemory.scope to 'thread'.`
+      );
+    }
     if (scope === "resource" && resourceId) {
       const resource = await this.storage.getResourceById({ resourceId });
       workingMemoryData = resource?.workingMemory || null;
@@ -827,7 +757,7 @@ ${template.content !== this.defaultWorkingMemoryTemplate ? `- Only store informa
     const isMDWorkingMemory = !(`schema` in config.workingMemory) && (typeof config.workingMemory.template === `string` || config.workingMemory.template) && config.workingMemory;
     return Boolean(isMDWorkingMemory && isMDWorkingMemory.version === `vnext`);
   }
-  getTools(config) {
+  listTools(config) {
     const mergedConfig = this.getMergedThreadConfig(config);
     if (mergedConfig.workingMemory?.enabled) {
       return {