@mastra/memory 0.11.6-alpha.1 → 0.11.6-alpha.2

package/.turbo/turbo-build.log

@@ -1,9 +1,9 @@
 
-> @mastra/memory@0.11.6-alpha.1 build /home/runner/work/mastra/mastra/packages/memory
+> @mastra/memory@0.11.6-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.11.6-alpha.1 check /home/runner/work/mastra/mastra/packages/memory
+> @mastra/memory@0.11.6-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,33 @@
 # @mastra/memory
 
+## 0.11.6-alpha.2
+
+### Patch Changes
+
+- ff9c125: enhance thread retrieval with sorting options in libsql and pg
+- b8efbb9: feat: add flexible deleteMessages method to memory API
+  - Added `memory.deleteMessages(input)` method that accepts multiple input types:
+    - Single message ID as string: `deleteMessages('msg-123')`
+    - Array of message IDs: `deleteMessages(['msg-1', 'msg-2'])`
+    - Message object with id property: `deleteMessages({ id: 'msg-123' })`
+    - Array of message objects: `deleteMessages([{ id: 'msg-1' }, { id: 'msg-2' }])`
+  - Implemented in all storage adapters (LibSQL, PostgreSQL, Upstash, InMemory)
+  - Added REST API endpoint: `POST /api/memory/messages/delete`
+  - Updated client SDK: `thread.deleteMessages()` accepts all input types
+  - Updates thread timestamps when messages are deleted
+  - Added comprehensive test coverage and documentation
+
+- Updated dependencies [27cc97a]
+- Updated dependencies [41daa63]
+- Updated dependencies [254a36b]
+- Updated dependencies [0b89602]
+- Updated dependencies [4d37822]
+- Updated dependencies [ff9c125]
+- Updated dependencies [b8efbb9]
+- Updated dependencies [71466e7]
+- Updated dependencies [0c99fbe]
+  - @mastra/core@0.12.0-alpha.2
+
 ## 0.11.6-alpha.1
 
 ### Patch Changes

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

@@ -13,6 +13,7 @@ import type { MemoryProcessorOpts } from '@mastra/core';
 import type { SharedMemoryConfig } from '@mastra/core/memory';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
+import type { ThreadSortOptions } from '@mastra/core/storage';
 import type { TiktokenBPE } from 'js-tiktoken/lite';
 import type { UIMessageWithMetadata } from '@mastra/core/agent';
 import type { WorkingMemoryTemplate } from '@mastra/core/memory';
@@ -46,9 +47,9 @@ export declare class Memory extends MastraMemory {
     getThreadById({ threadId }: {
         threadId: string;
     }): Promise<StorageThreadType | null>;
-    getThreadsByResourceId({ resourceId }: {
+    getThreadsByResourceId({ resourceId, orderBy, sortDirection, }: {
         resourceId: string;
-    }): Promise<StorageThreadType[]>;
+    } & ThreadSortOptions): Promise<StorageThreadType[]>;
     saveThread({ thread }: {
         thread: StorageThreadType;
         memoryConfig?: MemoryConfig;
@@ -142,8 +143,20 @@ export declare class Memory extends MastraMemory {
             id: string;
         }[];
     }): Promise<MastraMessageV2[]>;
+    /**
+     * Deletes one or more messages
+     * @param input - Must be an array containing either:
+     *   - Message ID strings
+     *   - Message objects with 'id' properties
+     * @returns Promise that resolves when all messages are deleted
+     */
+    deleteMessages(input: MessageDeleteInput): Promise<void>;
 }
 
+export declare type MessageDeleteInput = string[] | {
+    id: string;
+}[];
+
 /**
  * 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

@@ -13,6 +13,7 @@ import type { MemoryProcessorOpts } from '@mastra/core';
 import type { SharedMemoryConfig } from '@mastra/core/memory';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
+import type { ThreadSortOptions } from '@mastra/core/storage';
 import type { TiktokenBPE } from 'js-tiktoken/lite';
 import type { UIMessageWithMetadata } from '@mastra/core/agent';
 import type { WorkingMemoryTemplate } from '@mastra/core/memory';
@@ -46,9 +47,9 @@ export declare class Memory extends MastraMemory {
     getThreadById({ threadId }: {
         threadId: string;
     }): Promise<StorageThreadType | null>;
-    getThreadsByResourceId({ resourceId }: {
+    getThreadsByResourceId({ resourceId, orderBy, sortDirection, }: {
         resourceId: string;
-    }): Promise<StorageThreadType[]>;
+    } & ThreadSortOptions): Promise<StorageThreadType[]>;
     saveThread({ thread }: {
         thread: StorageThreadType;
         memoryConfig?: MemoryConfig;
@@ -142,8 +143,20 @@ export declare class Memory extends MastraMemory {
             id: string;
         }[];
     }): Promise<MastraMessageV2[]>;
+    /**
+     * Deletes one or more messages
+     * @param input - Must be an array containing either:
+     *   - Message ID strings
+     *   - Message objects with 'id' properties
+     * @returns Promise that resolves when all messages are deleted
+     */
+    deleteMessages(input: MessageDeleteInput): Promise<void>;
 }
 
+export declare type MessageDeleteInput = string[] | {
+    id: string;
+}[];
+
 /**
  * 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

@@ -27,9 +27,13 @@ var updateWorkingMemoryTool = (memoryConfig) => ({
     if (!threadId || !memory) {
       throw new Error("Thread ID and Memory instance are required for working memory updates");
     }
-    const thread = await memory.getThreadById({ threadId });
+    let thread = await memory.getThreadById({ threadId });
     if (!thread) {
-      throw new Error(`Thread ${threadId} not found`);
+      thread = await memory.createThread({
+        threadId,
+        resourceId: resourceId || thread.resourceId,
+        memoryConfig
+      });
     }
     if (thread.resourceId && thread.resourceId !== resourceId) {
       throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
@@ -60,9 +64,13 @@ var __experimental_updateWorkingMemoryToolVNext = (config) => ({
     if (!threadId || !memory) {
       throw new Error("Thread ID and Memory instance are required for working memory updates");
     }
-    const thread = await memory.getThreadById({ threadId });
+    let thread = await memory.getThreadById({ threadId });
     if (!thread) {
-      throw new Error(`Thread ${threadId} not found`);
+      thread = await memory.createThread({
+        threadId,
+        resourceId: resourceId || thread.resourceId,
+        config
+      });
     }
     if (thread.resourceId && thread.resourceId !== resourceId) {
       throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
@@ -252,8 +260,12 @@ var Memory = class extends memory.MastraMemory {
   async getThreadById({ threadId }) {
     return this.storage.getThreadById({ threadId });
   }
-  async getThreadsByResourceId({ resourceId }) {
-    return this.storage.getThreadsByResourceId({ resourceId });
+  async getThreadsByResourceId({
+    resourceId,
+    orderBy,
+    sortDirection
+  }) {
+    return this.storage.getThreadsByResourceId({ resourceId, orderBy, sortDirection });
   }
   async saveThread({ thread }) {
     return this.storage.saveThread({ thread });
@@ -752,6 +764,36 @@ ${template.content !== this.defaultWorkingMemoryTemplate ? `- Only store informa
     if (messages.length === 0) return [];
     return this.storage.updateMessages({ messages });
   }
+  /**
+   * Deletes one or more messages
+   * @param input - Must be an array containing either:
+   *   - Message ID strings
+   *   - Message objects with 'id' properties
+   * @returns Promise that resolves when all messages are deleted
+   */
+  async deleteMessages(input) {
+    let messageIds;
+    if (!Array.isArray(input)) {
+      throw new Error("Invalid input: must be an array of message IDs or message objects");
+    }
+    if (input.length === 0) {
+      return;
+    }
+    messageIds = input.map((item) => {
+      if (typeof item === "string") {
+        return item;
+      } else if (item && typeof item === "object" && "id" in item) {
+        return item.id;
+      } else {
+        throw new Error("Invalid input: array items must be strings or objects with an id property");
+      }
+    });
+    const invalidIds = messageIds.filter((id) => !id || typeof id !== "string");
+    if (invalidIds.length > 0) {
+      throw new Error("All message IDs must be non-empty strings");
+    }
+    await this.storage.deleteMessages(messageIds);
+  }
 };
 
 exports.Memory = Memory;

package/dist/index.d.cts

@@ -1 +1,2 @@
+export { MessageDeleteInput } from './_tsup-dts-rollup.cjs';
 export { Memory } from './_tsup-dts-rollup.cjs';

package/dist/index.d.ts

@@ -1 +1,2 @@
+export { MessageDeleteInput } from './_tsup-dts-rollup.js';
 export { Memory } from './_tsup-dts-rollup.js';

package/dist/index.js

@@ -20,9 +20,13 @@ var updateWorkingMemoryTool = (memoryConfig) => ({
     if (!threadId || !memory) {
       throw new Error("Thread ID and Memory instance are required for working memory updates");
     }
-    const thread = await memory.getThreadById({ threadId });
+    let thread = await memory.getThreadById({ threadId });
     if (!thread) {
-      throw new Error(`Thread ${threadId} not found`);
+      thread = await memory.createThread({
+        threadId,
+        resourceId: resourceId || thread.resourceId,
+        memoryConfig
+      });
     }
     if (thread.resourceId && thread.resourceId !== resourceId) {
       throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
@@ -53,9 +57,13 @@ var __experimental_updateWorkingMemoryToolVNext = (config) => ({
     if (!threadId || !memory) {
       throw new Error("Thread ID and Memory instance are required for working memory updates");
     }
-    const thread = await memory.getThreadById({ threadId });
+    let thread = await memory.getThreadById({ threadId });
     if (!thread) {
-      throw new Error(`Thread ${threadId} not found`);
+      thread = await memory.createThread({
+        threadId,
+        resourceId: resourceId || thread.resourceId,
+        config
+      });
     }
     if (thread.resourceId && thread.resourceId !== resourceId) {
       throw new Error(`Thread with id ${threadId} resourceId does not match the current resourceId ${resourceId}`);
@@ -245,8 +253,12 @@ var Memory = class extends MastraMemory {
   async getThreadById({ threadId }) {
     return this.storage.getThreadById({ threadId });
   }
-  async getThreadsByResourceId({ resourceId }) {
-    return this.storage.getThreadsByResourceId({ resourceId });
+  async getThreadsByResourceId({
+    resourceId,
+    orderBy,
+    sortDirection
+  }) {
+    return this.storage.getThreadsByResourceId({ resourceId, orderBy, sortDirection });
   }
   async saveThread({ thread }) {
     return this.storage.saveThread({ thread });
@@ -745,6 +757,36 @@ ${template.content !== this.defaultWorkingMemoryTemplate ? `- Only store informa
     if (messages.length === 0) return [];
     return this.storage.updateMessages({ messages });
   }
+  /**
+   * Deletes one or more messages
+   * @param input - Must be an array containing either:
+   *   - Message ID strings
+   *   - Message objects with 'id' properties
+   * @returns Promise that resolves when all messages are deleted
+   */
+  async deleteMessages(input) {
+    let messageIds;
+    if (!Array.isArray(input)) {
+      throw new Error("Invalid input: must be an array of message IDs or message objects");
+    }
+    if (input.length === 0) {
+      return;
+    }
+    messageIds = input.map((item) => {
+      if (typeof item === "string") {
+        return item;
+      } else if (item && typeof item === "object" && "id" in item) {
+        return item.id;
+      } else {
+        throw new Error("Invalid input: array items must be strings or objects with an id property");
+      }
+    });
+    const invalidIds = messageIds.filter((id) => !id || typeof id !== "string");
+    if (invalidIds.length > 0) {
+      throw new Error("All message IDs must be non-empty strings");
+    }
+    await this.storage.deleteMessages(messageIds);
+  }
 };
 
 export { Memory };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/memory",
-  "version": "0.11.6-alpha.1",
+  "version": "0.11.6-alpha.2",
   "description": "",
   "type": "module",
   "main": "./dist/index.js",
@@ -57,7 +57,7 @@
     "typescript-eslint": "^8.38.0",
     "vitest": "^3.2.4",
     "@internal/lint": "0.0.23",
-    "@mastra/core": "0.12.0-alpha.1"
+    "@mastra/core": "0.12.0-alpha.2"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.9-0 <0.12.0-0"

package/src/index.ts

@@ -4,7 +4,7 @@ import { MessageList } from '@mastra/core/agent';
 import type { MastraMessageV2, UIMessageWithMetadata } from '@mastra/core/agent';
 import { MastraMemory } from '@mastra/core/memory';
 import type { MemoryConfig, SharedMemoryConfig, StorageThreadType, WorkingMemoryTemplate } from '@mastra/core/memory';
-import type { StorageGetMessagesArg } from '@mastra/core/storage';
+import type { StorageGetMessagesArg, ThreadSortOptions } from '@mastra/core/storage';
 import { embedMany } from 'ai';
 import type { CoreMessage, TextPart } from 'ai';
 import { Mutex } from 'async-mutex';
@@ -16,6 +16,9 @@ import type { ZodTypeAny } from 'zod';
 import zodToJsonSchema from 'zod-to-json-schema';
 import { updateWorkingMemoryTool, __experimental_updateWorkingMemoryToolVNext } from './tools/working-memory';
 
+// Type for flexible message deletion input
+export type MessageDeleteInput = string[] | { id: string }[];
+
 // Average characters per token based on OpenAI's tokenization
 const CHARS_PER_TOKEN = 4;
 
@@ -247,8 +250,12 @@ export class Memory extends MastraMemory {
     return this.storage.getThreadById({ threadId });
   }
 
-  async getThreadsByResourceId({ resourceId }: { resourceId: string }): Promise<StorageThreadType[]> {
-    return this.storage.getThreadsByResourceId({ resourceId });
+  async getThreadsByResourceId({
+    resourceId,
+    orderBy,
+    sortDirection,
+  }: { resourceId: string } & ThreadSortOptions): Promise<StorageThreadType[]> {
+    return this.storage.getThreadsByResourceId({ resourceId, orderBy, sortDirection });
   }
 
   async saveThread({ thread }: { thread: StorageThreadType; memoryConfig?: MemoryConfig }): Promise<StorageThreadType> {
@@ -946,4 +953,47 @@ ${
 
     return this.storage.updateMessages({ messages });
   }
+
+  /**
+   * Deletes one or more messages
+   * @param input - Must be an array containing either:
+   *   - Message ID strings
+   *   - Message objects with 'id' properties
+   * @returns Promise that resolves when all messages are deleted
+   */
+  public async deleteMessages(input: MessageDeleteInput): Promise<void> {
+    // Normalize input to array of IDs
+    let messageIds: string[];
+
+    if (!Array.isArray(input)) {
+      throw new Error('Invalid input: must be an array of message IDs or message objects');
+    }
+
+    if (input.length === 0) {
+      return; // No-op for empty array
+    }
+
+    messageIds = input.map(item => {
+      if (typeof item === 'string') {
+        return item;
+      } else if (item && typeof item === 'object' && 'id' in item) {
+        return item.id;
+      } else {
+        throw new Error('Invalid input: array items must be strings or objects with an id property');
+      }
+    });
+
+    // Validate all IDs are non-empty strings
+    const invalidIds = messageIds.filter(id => !id || typeof id !== 'string');
+    if (invalidIds.length > 0) {
+      throw new Error('All message IDs must be non-empty strings');
+    }
+
+    // Delete from storage
+    await this.storage.deleteMessages(messageIds);
+
+    // TODO: Delete from vector store if semantic recall is enabled
+    // This would require getting the messages first to know their threadId/resourceId
+    // and then querying the vector store to delete associated embeddings
+  }
 }

package/src/tools/working-memory.ts

@@ -17,10 +17,14 @@ export const updateWorkingMemoryTool = (memoryConfig?: MemoryConfig): CoreTool =
       throw new Error('Thread ID and Memory instance are required for working memory updates');
     }
 
-    const thread = await memory.getThreadById({ threadId });
+    let thread = await memory.getThreadById({ threadId });
 
     if (!thread) {
-      throw new Error(`Thread ${threadId} not found`);
+      thread = await memory.createThread({
+        threadId,
+        resourceId: resourceId || thread.resourceId,
+        memoryConfig,
+      });
     }
 
     if (thread.resourceId && thread.resourceId !== resourceId) {
@@ -70,10 +74,14 @@ export const __experimental_updateWorkingMemoryToolVNext = (config: MemoryConfig
       throw new Error('Thread ID and Memory instance are required for working memory updates');
     }
 
-    const thread = await memory.getThreadById({ threadId });
+    let thread = await memory.getThreadById({ threadId });
 
     if (!thread) {
-      throw new Error(`Thread ${threadId} not found`);
+      thread = await memory.createThread({
+        threadId,
+        resourceId: resourceId || thread.resourceId,
+        config,
+      });
     }
 
     if (thread.resourceId && thread.resourceId !== resourceId) {