@mastra/client-js 0.10.17-alpha.1 → 0.10.17-alpha.2

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @mastra/client-js@0.10.17-alpha.1 build /home/runner/work/mastra/mastra/client-sdks/client-js
+> @mastra/client-js@0.10.17-alpha.2 build /home/runner/work/mastra/mastra/client-sdks/client-js
 > tsup src/index.ts --format esm,cjs --dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
@@ -9,11 +9,11 @@
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 74.04 KB
-CJS ⚡️ Build success in 2302ms
-ESM dist/index.js 73.73 KB
-ESM ⚡️ Build success in 2304ms
+ESM dist/index.js 74.97 KB
+ESM ⚡️ Build success in 1712ms
+CJS dist/index.cjs 75.29 KB
+CJS ⚡️ Build success in 1713ms
 DTS Build start
-DTS ⚡️ Build success in 19056ms
-DTS dist/index.d.ts  46.21 KB
-DTS dist/index.d.cts 46.21 KB
+DTS ⚡️ Build success in 16680ms
+DTS dist/index.d.ts  47.13 KB
+DTS dist/index.d.cts 47.13 KB

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @mastra/client-js
 
+## 0.10.17-alpha.2
+
+### Patch Changes
+
+- aa2715b: process stream response error handling
+- 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.10.17-alpha.1
 
 ### Patch Changes

package/dist/index.cjs

@@ -804,7 +804,9 @@ var Agent = class extends BaseResource {
                     messages: [...messageArray, ...messages, lastMessage]
                   },
                   writable
-                );
+                ).catch((error) => {
+                  console.error("Error processing stream response:", error);
+                });
               }
             }
           } else {
@@ -814,6 +816,8 @@ var Agent = class extends BaseResource {
           }
         },
         lastMessage: void 0
+      }).catch((error) => {
+        console.error("Error processing stream response:", error);
       });
     } catch (error) {
       console.error("Error processing stream response:", error);
@@ -977,6 +981,21 @@ var MemoryThread = class extends BaseResource {
     });
     return this.request(`/api/memory/threads/${this.threadId}/messages/paginated?${query.toString()}`);
   }
+  /**
+   * Deletes one or more messages from the thread
+   * @param messageIds - Can be a single message ID (string), array of message IDs,
+   *                     message object with id property, or array of message objects
+   * @returns Promise containing deletion result
+   */
+  deleteMessages(messageIds) {
+    const query = new URLSearchParams({
+      agentId: this.agentId
+    });
+    return this.request(`/api/memory/messages/delete?${query.toString()}`, {
+      method: "POST",
+      body: { messageIds }
+    });
+  }
 };
 
 // src/resources/vector.ts
@@ -1725,6 +1744,21 @@ var NetworkMemoryThread = class extends BaseResource {
     });
     return this.request(`/api/memory/network/threads/${this.threadId}/messages?${query.toString()}`);
   }
+  /**
+   * Deletes one or more messages from the thread
+   * @param messageIds - Can be a single message ID (string), array of message IDs,
+   *                     message object with id property, or array of message objects
+   * @returns Promise containing deletion result
+   */
+  deleteMessages(messageIds) {
+    const query = new URLSearchParams({
+      networkId: this.networkId
+    });
+    return this.request(`/api/memory/network/messages/delete?${query.toString()}`, {
+      method: "POST",
+      body: { messageIds }
+    });
+  }
 };
 
 // src/resources/vNextNetwork.ts

package/dist/index.d.cts

@@ -601,6 +601,20 @@ declare class MemoryThread extends BaseResource {
      * @returns Promise containing paginated thread messages with pagination metadata (total, page, perPage, hasMore)
      */
     getMessagesPaginated({ selectBy, ...rest }: GetMemoryThreadMessagesPaginatedParams): Promise<GetMemoryThreadMessagesPaginatedResponse>;
+    /**
+     * Deletes one or more messages from the thread
+     * @param messageIds - Can be a single message ID (string), array of message IDs,
+     *                     message object with id property, or array of message objects
+     * @returns Promise containing deletion result
+     */
+    deleteMessages(messageIds: string | string[] | {
+        id: string;
+    } | {
+        id: string;
+    }[]): Promise<{
+        success: boolean;
+        message: string;
+    }>;
 }
 
 declare class Vector extends BaseResource {
@@ -998,6 +1012,20 @@ declare class NetworkMemoryThread extends BaseResource {
      * @returns Promise containing thread messages and UI messages
      */
     getMessages(params?: GetMemoryThreadMessagesParams): Promise<GetMemoryThreadMessagesResponse>;
+    /**
+     * Deletes one or more messages from the thread
+     * @param messageIds - Can be a single message ID (string), array of message IDs,
+     *                     message object with id property, or array of message objects
+     * @returns Promise containing deletion result
+     */
+    deleteMessages(messageIds: string | string[] | {
+        id: string;
+    } | {
+        id: string;
+    }[]): Promise<{
+        success: boolean;
+        message: string;
+    }>;
 }
 
 declare class VNextNetwork extends BaseResource {

package/dist/index.d.ts

@@ -601,6 +601,20 @@ declare class MemoryThread extends BaseResource {
      * @returns Promise containing paginated thread messages with pagination metadata (total, page, perPage, hasMore)
      */
     getMessagesPaginated({ selectBy, ...rest }: GetMemoryThreadMessagesPaginatedParams): Promise<GetMemoryThreadMessagesPaginatedResponse>;
+    /**
+     * Deletes one or more messages from the thread
+     * @param messageIds - Can be a single message ID (string), array of message IDs,
+     *                     message object with id property, or array of message objects
+     * @returns Promise containing deletion result
+     */
+    deleteMessages(messageIds: string | string[] | {
+        id: string;
+    } | {
+        id: string;
+    }[]): Promise<{
+        success: boolean;
+        message: string;
+    }>;
 }
 
 declare class Vector extends BaseResource {
@@ -998,6 +1012,20 @@ declare class NetworkMemoryThread extends BaseResource {
      * @returns Promise containing thread messages and UI messages
      */
     getMessages(params?: GetMemoryThreadMessagesParams): Promise<GetMemoryThreadMessagesResponse>;
+    /**
+     * Deletes one or more messages from the thread
+     * @param messageIds - Can be a single message ID (string), array of message IDs,
+     *                     message object with id property, or array of message objects
+     * @returns Promise containing deletion result
+     */
+    deleteMessages(messageIds: string | string[] | {
+        id: string;
+    } | {
+        id: string;
+    }[]): Promise<{
+        success: boolean;
+        message: string;
+    }>;
 }
 
 declare class VNextNetwork extends BaseResource {

package/dist/index.js

@@ -798,7 +798,9 @@ var Agent = class extends BaseResource {
                     messages: [...messageArray, ...messages, lastMessage]
                   },
                   writable
-                );
+                ).catch((error) => {
+                  console.error("Error processing stream response:", error);
+                });
               }
             }
           } else {
@@ -808,6 +810,8 @@ var Agent = class extends BaseResource {
           }
         },
         lastMessage: void 0
+      }).catch((error) => {
+        console.error("Error processing stream response:", error);
       });
     } catch (error) {
       console.error("Error processing stream response:", error);
@@ -971,6 +975,21 @@ var MemoryThread = class extends BaseResource {
     });
     return this.request(`/api/memory/threads/${this.threadId}/messages/paginated?${query.toString()}`);
   }
+  /**
+   * Deletes one or more messages from the thread
+   * @param messageIds - Can be a single message ID (string), array of message IDs,
+   *                     message object with id property, or array of message objects
+   * @returns Promise containing deletion result
+   */
+  deleteMessages(messageIds) {
+    const query = new URLSearchParams({
+      agentId: this.agentId
+    });
+    return this.request(`/api/memory/messages/delete?${query.toString()}`, {
+      method: "POST",
+      body: { messageIds }
+    });
+  }
 };
 
 // src/resources/vector.ts
@@ -1719,6 +1738,21 @@ var NetworkMemoryThread = class extends BaseResource {
     });
     return this.request(`/api/memory/network/threads/${this.threadId}/messages?${query.toString()}`);
   }
+  /**
+   * Deletes one or more messages from the thread
+   * @param messageIds - Can be a single message ID (string), array of message IDs,
+   *                     message object with id property, or array of message objects
+   * @returns Promise containing deletion result
+   */
+  deleteMessages(messageIds) {
+    const query = new URLSearchParams({
+      networkId: this.networkId
+    });
+    return this.request(`/api/memory/network/messages/delete?${query.toString()}`, {
+      method: "POST",
+      body: { messageIds }
+    });
+  }
 };
 
 // src/resources/vNextNetwork.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.10.17-alpha.1",
+  "version": "0.10.17-alpha.2",
   "description": "The official TypeScript library for the Mastra Client API",
   "author": "",
   "type": "module",
@@ -34,7 +34,7 @@
     "rxjs": "7.8.1",
     "zod": "^3.25.67",
     "zod-to-json-schema": "^3.24.5",
-    "@mastra/core": "0.12.0-alpha.1"
+    "@mastra/core": "0.12.0-alpha.2"
   },
   "peerDependencies": {
     "zod": "^3.0.0"

package/src/resources/agent.ts

@@ -714,7 +714,9 @@ export class Agent extends BaseResource {
                     messages: [...messageArray, ...messages, lastMessage],
                   },
                   writable,
-                );
+                ).catch(error => {
+                  console.error('Error processing stream response:', error);
+                });
               }
             }
           } else {
@@ -724,6 +726,8 @@ export class Agent extends BaseResource {
           }
         },
         lastMessage: undefined,
+      }).catch(error => {
+        console.error('Error processing stream response:', error);
       });
     } catch (error) {
       console.error('Error processing stream response:', error);

package/src/resources/memory-thread.test.ts

@@ -0,0 +1,285 @@
+import { describe, expect, beforeEach, it, vi } from 'vitest';
+import { MemoryThread } from './memory-thread';
+import type { ClientOptions } from '../types';
+
+// Mock fetch globally
+global.fetch = vi.fn();
+
+describe('MemoryThread', () => {
+  let thread: MemoryThread;
+  const clientOptions: ClientOptions = {
+    baseUrl: 'http://localhost:4111',
+    headers: {
+      Authorization: 'Bearer test-key',
+    },
+  };
+  const threadId = 'test-thread-id';
+  const agentId = 'test-agent-id';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    thread = new MemoryThread(clientOptions, threadId, agentId);
+  });
+
+  const mockFetchResponse = (data: any) => {
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => data,
+      headers: new Headers({
+        'content-type': 'application/json',
+      }),
+    });
+  };
+
+  describe('get', () => {
+    it('should retrieve thread details', async () => {
+      const mockThread = {
+        id: threadId,
+        title: 'Test Thread',
+        metadata: { test: true },
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      };
+
+      mockFetchResponse(mockThread);
+
+      const result = await thread.get();
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/threads/${threadId}?agentId=${agentId}`,
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+        }),
+      );
+      expect(result).toEqual(mockThread);
+    });
+  });
+
+  describe('update', () => {
+    it('should update thread properties', async () => {
+      const updateParams = {
+        title: 'Updated Title',
+        metadata: { updated: true },
+        resourceid: 'resource-1',
+      };
+
+      const mockUpdatedThread = {
+        id: threadId,
+        ...updateParams,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      };
+
+      mockFetchResponse(mockUpdatedThread);
+
+      const result = await thread.update(updateParams);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/threads/${threadId}?agentId=${agentId}`,
+        expect.objectContaining({
+          method: 'PATCH',
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+          body: JSON.stringify(updateParams),
+        }),
+      );
+      expect(result).toEqual(mockUpdatedThread);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete the thread', async () => {
+      const mockResponse = { result: 'Thread deleted' };
+      mockFetchResponse(mockResponse);
+
+      const result = await thread.delete();
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/threads/${threadId}?agentId=${agentId}`,
+        expect.objectContaining({
+          method: 'DELETE',
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+        }),
+      );
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('getMessages', () => {
+    it('should retrieve thread messages', async () => {
+      const mockMessages = {
+        messages: [
+          { id: 'msg-1', content: 'Hello', role: 'user' },
+          { id: 'msg-2', content: 'Hi there', role: 'assistant' },
+        ],
+        uiMessages: [
+          { id: 'msg-1', content: 'Hello', role: 'user' },
+          { id: 'msg-2', content: 'Hi there', role: 'assistant' },
+        ],
+      };
+
+      mockFetchResponse(mockMessages);
+
+      const result = await thread.getMessages();
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/threads/${threadId}/messages?agentId=${agentId}`,
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+        }),
+      );
+      expect(result).toEqual(mockMessages);
+    });
+
+    it('should retrieve thread messages with limit', async () => {
+      const mockMessages = {
+        messages: [{ id: 'msg-1', content: 'Hello', role: 'user' }],
+        uiMessages: [{ id: 'msg-1', content: 'Hello', role: 'user' }],
+      };
+
+      mockFetchResponse(mockMessages);
+
+      const result = await thread.getMessages({ limit: 5 });
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/threads/${threadId}/messages?agentId=${agentId}&limit=5`,
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+        }),
+      );
+      expect(result).toEqual(mockMessages);
+    });
+  });
+
+  describe('deleteMessages', () => {
+    it('should delete a single message by string ID', async () => {
+      const messageId = 'test-message-id';
+      const mockResponse = { success: true, message: '1 message deleted successfully' };
+
+      mockFetchResponse(mockResponse);
+
+      const result = await thread.deleteMessages(messageId);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/messages/delete?agentId=${agentId}`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'content-type': 'application/json',
+            Authorization: 'Bearer test-key',
+          }),
+          body: JSON.stringify({ messageIds: messageId }),
+        }),
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should delete multiple messages by array of string IDs', async () => {
+      const messageIds = ['msg-1', 'msg-2', 'msg-3'];
+      const mockResponse = { success: true, message: '3 messages deleted successfully' };
+
+      mockFetchResponse(mockResponse);
+
+      const result = await thread.deleteMessages(messageIds);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/messages/delete?agentId=${agentId}`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'content-type': 'application/json',
+            Authorization: 'Bearer test-key',
+          }),
+          body: JSON.stringify({ messageIds }),
+        }),
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should delete a message by object with id property', async () => {
+      const messageObj = { id: 'test-message-id' };
+      const mockResponse = { success: true, message: '1 message deleted successfully' };
+
+      mockFetchResponse(mockResponse);
+
+      const result = await thread.deleteMessages(messageObj);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/messages/delete?agentId=${agentId}`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'content-type': 'application/json',
+            Authorization: 'Bearer test-key',
+          }),
+          body: JSON.stringify({ messageIds: messageObj }),
+        }),
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should delete messages by array of objects', async () => {
+      const messageObjs = [{ id: 'msg-1' }, { id: 'msg-2' }];
+      const mockResponse = { success: true, message: '2 messages deleted successfully' };
+
+      mockFetchResponse(mockResponse);
+
+      const result = await thread.deleteMessages(messageObjs);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/messages/delete?agentId=${agentId}`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'content-type': 'application/json',
+            Authorization: 'Bearer test-key',
+          }),
+          body: JSON.stringify({ messageIds: messageObjs }),
+        }),
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should handle empty array', async () => {
+      const messageIds: string[] = [];
+
+      (global.fetch as any).mockResolvedValueOnce({
+        ok: false,
+        status: 400,
+        statusText: 'Bad Request',
+        json: async () => ({ error: 'messageIds array cannot be empty' }),
+        headers: new Headers({
+          'content-type': 'application/json',
+        }),
+      });
+
+      await expect(thread.deleteMessages(messageIds)).rejects.toThrow();
+    });
+
+    it('should handle bulk delete errors', async () => {
+      const messageIds = ['msg-1', 'msg-2'];
+
+      (global.fetch as any).mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        json: async () => ({ error: 'Database error' }),
+        headers: new Headers({
+          'content-type': 'application/json',
+        }),
+      });
+
+      await expect(thread.deleteMessages(messageIds)).rejects.toThrow();
+    });
+  });
+});

package/src/resources/memory-thread.ts

@@ -78,4 +78,22 @@ export class MemoryThread extends BaseResource {
     });
     return this.request(`/api/memory/threads/${this.threadId}/messages/paginated?${query.toString()}`);
   }
+
+  /**
+   * Deletes one or more messages from the thread
+   * @param messageIds - Can be a single message ID (string), array of message IDs,
+   *                     message object with id property, or array of message objects
+   * @returns Promise containing deletion result
+   */
+  deleteMessages(
+    messageIds: string | string[] | { id: string } | { id: string }[],
+  ): Promise<{ success: boolean; message: string }> {
+    const query = new URLSearchParams({
+      agentId: this.agentId,
+    });
+    return this.request(`/api/memory/messages/delete?${query.toString()}`, {
+      method: 'POST',
+      body: { messageIds },
+    });
+  }
 }

package/src/resources/network-memory-thread.test.ts

@@ -0,0 +1,269 @@
+import { describe, expect, beforeEach, it, vi } from 'vitest';
+import { NetworkMemoryThread } from './network-memory-thread';
+import type { ClientOptions } from '../types';
+
+// Mock fetch globally
+global.fetch = vi.fn();
+
+describe('NetworkMemoryThread', () => {
+  let thread: NetworkMemoryThread;
+  const clientOptions: ClientOptions = {
+    baseUrl: 'http://localhost:4111',
+    headers: {
+      Authorization: 'Bearer test-key',
+    },
+  };
+  const threadId = 'test-thread-id';
+  const networkId = 'test-network-id';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    thread = new NetworkMemoryThread(clientOptions, threadId, networkId);
+  });
+
+  const mockFetchResponse = (data: any) => {
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => data,
+      headers: new Headers({
+        'content-type': 'application/json',
+      }),
+    });
+  };
+
+  describe('get', () => {
+    it('should retrieve thread details', async () => {
+      const mockThread = {
+        id: threadId,
+        title: 'Test Thread',
+        metadata: { test: true },
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      };
+
+      mockFetchResponse(mockThread);
+
+      const result = await thread.get();
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/threads/${threadId}?networkId=${networkId}`,
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+        }),
+      );
+      expect(result).toEqual(mockThread);
+    });
+  });
+
+  describe('update', () => {
+    it('should update thread properties', async () => {
+      const updateParams = {
+        title: 'Updated Title',
+        metadata: { updated: true },
+        resourceid: 'resource-1',
+      };
+
+      const mockUpdatedThread = {
+        id: threadId,
+        ...updateParams,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      };
+
+      mockFetchResponse(mockUpdatedThread);
+
+      const result = await thread.update(updateParams);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/threads/${threadId}?networkId=${networkId}`,
+        expect.objectContaining({
+          method: 'PATCH',
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+          body: JSON.stringify(updateParams),
+        }),
+      );
+      expect(result).toEqual(mockUpdatedThread);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete the thread', async () => {
+      const mockResponse = { result: 'Thread deleted' };
+      mockFetchResponse(mockResponse);
+
+      const result = await thread.delete();
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/threads/${threadId}?networkId=${networkId}`,
+        expect.objectContaining({
+          method: 'DELETE',
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+        }),
+      );
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('getMessages', () => {
+    it('should retrieve thread messages', async () => {
+      const mockMessages = {
+        messages: [
+          { id: 'msg-1', content: 'Hello', role: 'user' },
+          { id: 'msg-2', content: 'Hi there', role: 'assistant' },
+        ],
+        uiMessages: [
+          { id: 'msg-1', content: 'Hello', role: 'user' },
+          { id: 'msg-2', content: 'Hi there', role: 'assistant' },
+        ],
+      };
+
+      mockFetchResponse(mockMessages);
+
+      const result = await thread.getMessages();
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/threads/${threadId}/messages?networkId=${networkId}`,
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+        }),
+      );
+      expect(result).toEqual(mockMessages);
+    });
+
+    it('should retrieve thread messages with limit', async () => {
+      const mockMessages = {
+        messages: [{ id: 'msg-1', content: 'Hello', role: 'user' }],
+        uiMessages: [{ id: 'msg-1', content: 'Hello', role: 'user' }],
+      };
+
+      mockFetchResponse(mockMessages);
+
+      const result = await thread.getMessages({ limit: 5 });
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/threads/${threadId}/messages?networkId=${networkId}&limit=5`,
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+        }),
+      );
+      expect(result).toEqual(mockMessages);
+    });
+  });
+
+  describe('deleteMessages', () => {
+    it('should delete a single message by string ID', async () => {
+      const messageId = 'test-message-id';
+      const mockResponse = { success: true, message: '1 message deleted successfully' };
+
+      mockFetchResponse(mockResponse);
+
+      const result = await thread.deleteMessages(messageId);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/messages/delete?networkId=${networkId}`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'content-type': 'application/json',
+            Authorization: 'Bearer test-key',
+          }),
+          body: JSON.stringify({ messageIds: messageId }),
+        }),
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should delete multiple messages by array of string IDs', async () => {
+      const messageIds = ['msg-1', 'msg-2', 'msg-3'];
+      const mockResponse = { success: true, message: '3 messages deleted successfully' };
+
+      mockFetchResponse(mockResponse);
+
+      const result = await thread.deleteMessages(messageIds);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/messages/delete?networkId=${networkId}`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'content-type': 'application/json',
+            Authorization: 'Bearer test-key',
+          }),
+          body: JSON.stringify({ messageIds }),
+        }),
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should delete a message by object with id property', async () => {
+      const messageObj = { id: 'test-message-id' };
+      const mockResponse = { success: true, message: '1 message deleted successfully' };
+
+      mockFetchResponse(mockResponse);
+
+      const result = await thread.deleteMessages(messageObj);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/messages/delete?networkId=${networkId}`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'content-type': 'application/json',
+            Authorization: 'Bearer test-key',
+          }),
+          body: JSON.stringify({ messageIds: messageObj }),
+        }),
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should delete messages by array of objects', async () => {
+      const messageObjs = [{ id: 'msg-1' }, { id: 'msg-2' }];
+      const mockResponse = { success: true, message: '2 messages deleted successfully' };
+
+      mockFetchResponse(mockResponse);
+
+      const result = await thread.deleteMessages(messageObjs);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `http://localhost:4111/api/memory/network/messages/delete?networkId=${networkId}`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            'content-type': 'application/json',
+            Authorization: 'Bearer test-key',
+          }),
+          body: JSON.stringify({ messageIds: messageObjs }),
+        }),
+      );
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should handle delete messages errors', async () => {
+      const messageId = 'non-existent-id';
+
+      (global.fetch as any).mockResolvedValueOnce({
+        ok: false,
+        status: 404,
+        statusText: 'Not Found',
+        json: async () => ({ error: 'Message not found' }),
+        headers: new Headers({
+          'content-type': 'application/json',
+        }),
+      });
+
+      await expect(thread.deleteMessages(messageId)).rejects.toThrow();
+    });
+  });
+});

package/src/resources/network-memory-thread.ts

@@ -60,4 +60,22 @@ export class NetworkMemoryThread extends BaseResource {
     });
     return this.request(`/api/memory/network/threads/${this.threadId}/messages?${query.toString()}`);
   }
+
+  /**
+   * Deletes one or more messages from the thread
+   * @param messageIds - Can be a single message ID (string), array of message IDs,
+   *                     message object with id property, or array of message objects
+   * @returns Promise containing deletion result
+   */
+  deleteMessages(
+    messageIds: string | string[] | { id: string } | { id: string }[],
+  ): Promise<{ success: boolean; message: string }> {
+    const query = new URLSearchParams({
+      networkId: this.networkId,
+    });
+    return this.request(`/api/memory/network/messages/delete?${query.toString()}`, {
+      method: 'POST',
+      body: { messageIds },
+    });
+  }
 }