@mastra/client-js 0.0.0-fix-message-list-merge-20250718043058 → 0.0.0-fix-tool-call-history-20250731222019

package/src/resources/base.ts

@@ -24,7 +24,11 @@ export class BaseResource {
         const response = await fetch(`${baseUrl.replace(/\/$/, '')}${path}`, {
           ...options,
           headers: {
-            ...(options.method === 'POST' || options.method === 'PUT' ? { 'content-type': 'application/json' } : {}),
+            ...(options.body &&
+            !(options.body instanceof FormData) &&
+            (options.method === 'POST' || options.method === 'PUT')
+              ? { 'content-type': 'application/json' }
+              : {}),
             ...headers,
             ...options.headers,
             // TODO: Bring this back once we figure out what we/users need to do to make this work with cross-origin requests

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

@@ -5,6 +5,8 @@ import type {
   ClientOptions,
   UpdateMemoryThreadParams,
   GetMemoryThreadMessagesParams,
+  GetMemoryThreadMessagesPaginatedParams,
+  GetMemoryThreadMessagesPaginatedResponse,
 } from '../types';
 
 import { BaseResource } from './base';
@@ -60,4 +62,38 @@ export class MemoryThread extends BaseResource {
     });
     return this.request(`/api/memory/threads/${this.threadId}/messages?${query.toString()}`);
   }
+
+  /**
+   * Retrieves paginated messages associated with the thread with advanced filtering and selection options
+   * @param params - Pagination parameters including selectBy criteria, page, perPage, date ranges, and message inclusion options
+   * @returns Promise containing paginated thread messages with pagination metadata (total, page, perPage, hasMore)
+   */
+  getMessagesPaginated({
+    selectBy,
+    ...rest
+  }: GetMemoryThreadMessagesPaginatedParams): Promise<GetMemoryThreadMessagesPaginatedResponse> {
+    const query = new URLSearchParams({
+      ...rest,
+      ...(selectBy ? { selectBy: JSON.stringify(selectBy) } : {}),
+    });
+    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 },
+    });
+  }
 }

package/src/resources/network.ts

@@ -28,9 +28,10 @@ export class Network extends BaseResource {
    * @param params - Generation parameters including prompt
    * @returns Promise containing the generated response
    */
-  generate<T extends JSONSchema7 | ZodSchema | undefined = undefined>(
-    params: GenerateParams<T>,
-  ): Promise<GenerateReturn<T>> {
+  generate<
+    Output extends JSONSchema7 | ZodSchema | undefined = undefined,
+    StructuredOutput extends JSONSchema7 | ZodSchema | undefined = undefined,
+  >(params: GenerateParams<Output>): Promise<GenerateReturn<any, Output, StructuredOutput>> {
     const processedParams = {
       ...params,
       output: zodToJsonSchema(params.output),

package/src/resources/workflow.ts

@@ -190,6 +190,15 @@ export class Workflow extends BaseResource {
     });
   }
 
+  /**
+   * Creates a new workflow run (alias for createRun)
+   * @param params - Optional object containing the optional runId
+   * @returns Promise containing the runId of the created run
+   */
+  createRunAsync(params?: { runId?: string }): Promise<{ runId: string }> {
+    return this.createRun(params);
+  }
+
   /**
    * Starts a workflow run synchronously without waiting for the workflow to complete
    * @param params - Object containing the runId, inputData and runtimeContext