@mastra/client-js 0.0.0-mcp-changeset-20250707162621 → 0.0.0-memory-system-message-error-20250813233316

package/src/index.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, beforeEach, it, vi } from 'vitest';
 import { MastraClient } from './client';
-import type { McpServerListResponse, ServerDetailInfo } from './types';
+import type { McpServerListResponse } from './types';
+import type { ServerDetailInfo } from '@mastra/core/mcp';
+import { ScoringEntityType, ScoringSource } from '@mastra/core/scores';
 
 // Mock fetch globally
 global.fetch = vi.fn();
@@ -27,7 +29,13 @@ describe('MastraClient Resources', () => {
       } else {
         responseBody = new ReadableStream({
           start(controller) {
-            controller.enqueue(new TextEncoder().encode(JSON.stringify(data)));
+            if (typeof data === 'string') {
+              controller.enqueue(new TextEncoder().encode(data));
+            } else if (typeof data === 'object' && data !== null) {
+              controller.enqueue(new TextEncoder().encode(JSON.stringify(data)));
+            } else {
+              controller.enqueue(new TextEncoder().encode(String(data)));
+            }
             controller.close();
           },
         });
@@ -279,7 +287,7 @@ describe('MastraClient Resources', () => {
     });
 
     it('should stream responses', async () => {
-      const mockChunk = { content: 'test response' };
+      const mockChunk = `0:"test response"\n`;
       mockFetchResponse(mockChunk, { isStream: true });
 
       const response = await agent.stream({
@@ -298,10 +306,118 @@ describe('MastraClient Resources', () => {
       if (reader) {
         const { value, done } = await reader.read();
         expect(done).toBe(false);
-        expect(new TextDecoder().decode(value)).toBe(JSON.stringify(mockChunk));
+        expect(new TextDecoder().decode(value)).toBe(mockChunk);
       }
     });
 
+    it('should stream responses with tool calls', async () => {
+      const firstMockChunk = `0:"test "
+0:"response"
+9:{"toolCallId":"tool1","toolName":"testTool","args":{"arg1":"value1"}}
+e:{"finishReason":"tool-calls","usage":{"promptTokens":1,"completionTokens":1},"isContinued":false}
+d:{"finishReason":"tool-calls","usage":{"promptTokens":2,"completionTokens":2}}
+`;
+
+      const secondMockChunk = `0:"final response"
+e:{"finishReason":"stop","usage":{"promptTokens":2,"completionTokens":2},"isContinued":false}
+d:{"finishReason":"stop","usage":{"promptTokens":2,"completionTokens":2}}
+`;
+
+      const firstResponseBody = new ReadableStream({
+        start(controller) {
+          controller.enqueue(new TextEncoder().encode(firstMockChunk));
+          controller.close();
+        },
+      });
+
+      const secondResponseBody = new ReadableStream({
+        start(controller) {
+          controller.enqueue(new TextEncoder().encode(secondMockChunk));
+          controller.close();
+        },
+      });
+
+      (global.fetch as any)
+        .mockResolvedValueOnce(
+          new Response(firstResponseBody, {
+            status: 200,
+            headers: new Headers({ 'Content-Type': 'text/event-stream' }),
+          }),
+        )
+        .mockResolvedValueOnce(
+          new Response(secondResponseBody, {
+            status: 200,
+            headers: new Headers({ 'Content-Type': 'text/event-stream' }),
+          }),
+        );
+
+      const response = await agent.stream({
+        messages: [
+          {
+            role: 'user',
+            content: 'test',
+          },
+        ],
+        clientTools: {
+          testTool: {
+            id: 'testTool',
+            description: 'Test Tool',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                arg1: { type: 'string' },
+              },
+            },
+            execute: async () => {
+              return 'test result';
+            },
+          },
+        },
+      });
+
+      expect(response.body).toBeInstanceOf(ReadableStream);
+      const reader = response?.body?.getReader();
+      expect(reader).toBeDefined();
+
+      let output = '';
+      if (reader) {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          output += new TextDecoder().decode(value);
+        }
+      }
+
+      expect(global.fetch).toHaveBeenCalledTimes(2);
+
+      const [secondUrl, secondConfig] = (global.fetch as any).mock.calls[1];
+      expect(secondUrl).toBe(`${clientOptions.baseUrl}/api/agents/test-agent/stream`);
+
+      const secondRequestBody = JSON.parse(secondConfig.body);
+      expect(secondRequestBody.messages).toHaveLength(2);
+      expect(secondRequestBody.messages[0].content).toBe('test');
+      expect(secondRequestBody.messages[1].content).toBe('test response');
+      expect(secondRequestBody.messages[1].parts).toEqual([
+        {
+          type: 'text',
+          text: 'test response',
+        },
+        {
+          type: 'tool-invocation',
+          toolInvocation: {
+            state: 'result',
+            step: 0,
+            toolCallId: 'tool1',
+            toolName: 'testTool',
+            args: {
+              arg1: 'value1',
+            },
+            result: 'test result',
+          },
+        },
+      ]);
+    });
+
     it('should get agent tool', async () => {
       const mockResponse = {
         id: 'tool1',
@@ -582,6 +698,48 @@ describe('MastraClient Resources', () => {
         }),
       );
     });
+
+    it('should get paginated thread messages', async () => {
+      const mockResponse = {
+        messages: [
+          {
+            id: '1',
+            content: 'test message',
+            threadId,
+            role: 'user',
+            type: 'text',
+            resourceId: 'test-resource',
+            createdAt: new Date(),
+          },
+        ],
+        total: 5,
+        page: 1,
+        perPage: 2,
+        hasMore: true,
+      };
+      mockFetchResponse(mockResponse);
+
+      const selectBy = {
+        pagination: {
+          page: 1,
+          perPage: 2,
+        },
+      };
+
+      const result = await memoryThread.getMessagesPaginated({
+        resourceId: 'test-resource',
+        format: 'v2',
+        selectBy,
+      });
+
+      expect(result).toEqual(mockResponse);
+      expect(global.fetch).toHaveBeenCalledWith(
+        `${clientOptions.baseUrl}/api/memory/threads/${threadId}/messages/paginated?resourceId=test-resource&format=v2&selectBy=${encodeURIComponent(JSON.stringify(selectBy))}`,
+        expect.objectContaining({
+          headers: expect.objectContaining(clientOptions.headers),
+        }),
+      );
+    });
   });
 
   describe('Tool Resource', () => {
@@ -662,14 +820,14 @@ describe('MastraClient Resources', () => {
       };
       mockFetchResponse(mockResponse);
 
-      const result = await workflow.startAsync({ triggerData: { test: 'test' } });
+      const result = await workflow.startAsync({ inputData: { test: 'test' } });
       expect(result).toEqual(mockResponse);
       expect(global.fetch).toHaveBeenCalledWith(
         `${clientOptions.baseUrl}/api/workflows/test-workflow/start-async?`,
         expect.objectContaining({
           method: 'POST',
           headers: expect.objectContaining(clientOptions.headers),
-          body: JSON.stringify({ test: 'test' }),
+          body: JSON.stringify({ inputData: { test: 'test' } }),
         }),
       );
     });
@@ -827,4 +985,242 @@ describe('MastraClient Resources', () => {
       });
     });
   });
+
+  describe('Scores Methods', () => {
+    describe('getScorers()', () => {
+      it('should fetch all available scorers', async () => {
+        const mockResponse = {
+          scorers: [
+            { id: 'scorer-1', name: 'Test Scorer 1', description: 'A test scorer' },
+            { id: 'scorer-2', name: 'Test Scorer 2', description: 'Another test scorer' },
+          ],
+        };
+        mockFetchResponse(mockResponse);
+
+        const result = await client.getScorers();
+        expect(result).toEqual(mockResponse);
+        expect(global.fetch).toHaveBeenCalledWith(
+          `${clientOptions.baseUrl}/api/scores/scorers`,
+          expect.objectContaining({
+            headers: expect.objectContaining(clientOptions.headers),
+          }),
+        );
+      });
+    });
+
+    describe('getScoresByRunId()', () => {
+      it('should fetch scores by run ID without pagination', async () => {
+        const mockResponse = {
+          pagination: {
+            total: 10,
+            page: 0,
+            perPage: 10,
+            hasMore: false,
+          },
+          scores: [
+            {
+              id: 'score-1',
+              runId: 'run-123',
+              scorer: { name: 'test-scorer' },
+              result: { score: 0.8 },
+              input: { messages: [] },
+              output: { response: 'test' },
+              source: 'LIVE',
+              createdAt: new Date(),
+              updatedAt: new Date(),
+            },
+          ],
+        };
+
+        mockFetchResponse({
+          ...mockResponse,
+          scores: mockResponse.scores.map(score => ({
+            ...score,
+            createdAt: score.createdAt.toISOString(),
+            updatedAt: score.updatedAt.toISOString(),
+          })),
+        });
+
+        const result = await client.getScoresByRunId({ runId: 'run-123' });
+
+        expect(result).toEqual({
+          ...mockResponse,
+          scores: mockResponse.scores.map(score => ({
+            ...score,
+            createdAt: score.createdAt.toISOString(),
+            updatedAt: score.updatedAt.toISOString(),
+          })),
+        });
+
+        expect(global.fetch).toHaveBeenCalledWith(
+          `${clientOptions.baseUrl}/api/scores/run/run-123`,
+          expect.objectContaining({
+            headers: expect.objectContaining(clientOptions.headers),
+          }),
+        );
+      });
+
+      it('should fetch scores by run ID with pagination', async () => {
+        const mockResponse = {
+          pagination: {
+            total: 20,
+            page: 1,
+            perPage: 5,
+            hasMore: true,
+          },
+          scores: [],
+        };
+        mockFetchResponse(mockResponse);
+
+        const result = await client.getScoresByRunId({
+          runId: 'run-123',
+          page: 1,
+          perPage: 5,
+        });
+        expect(result).toEqual(mockResponse);
+        expect(global.fetch).toHaveBeenCalledWith(
+          `${clientOptions.baseUrl}/api/scores/run/run-123?page=1&perPage=5`,
+          expect.objectContaining({
+            headers: expect.objectContaining(clientOptions.headers),
+          }),
+        );
+      });
+    });
+
+    describe('getScoresByEntityId()', () => {
+      it('should fetch scores by entity ID and type without pagination', async () => {
+        const mockResponse = {
+          pagination: {
+            total: 5,
+            page: 0,
+            perPage: 10,
+            hasMore: false,
+          },
+          scores: [
+            {
+              id: 'score-1',
+              runId: 'run-123',
+              entityId: 'agent-456',
+              entityType: 'AGENT',
+              scorer: { name: 'test-scorer' },
+              result: { score: 0.9 },
+              input: { messages: [] },
+              output: { response: 'test' },
+              source: 'LIVE',
+              createdAt: new Date(),
+              updatedAt: new Date(),
+            },
+          ],
+        };
+
+        const mockResponseWithDates = mockResponse.scores.map(score => ({
+          ...score,
+          createdAt: score.createdAt.toISOString(),
+          updatedAt: score.updatedAt.toISOString(),
+        }));
+
+        mockFetchResponse({
+          ...mockResponse,
+          scores: mockResponseWithDates,
+        });
+
+        const result = await client.getScoresByEntityId({
+          entityId: 'agent-456',
+          entityType: 'AGENT',
+        });
+
+        expect(result).toEqual({
+          ...mockResponse,
+          scores: mockResponseWithDates,
+        });
+
+        expect(global.fetch).toHaveBeenCalledWith(
+          `${clientOptions.baseUrl}/api/scores/entity/AGENT/agent-456`,
+          expect.objectContaining({
+            headers: expect.objectContaining(clientOptions.headers),
+          }),
+        );
+      });
+
+      it('should fetch scores by entity ID and type with pagination', async () => {
+        const mockResponse = {
+          pagination: {
+            total: 15,
+            page: 2,
+            perPage: 5,
+            hasMore: true,
+          },
+          scores: [],
+        };
+        mockFetchResponse(mockResponse);
+
+        const result = await client.getScoresByEntityId({
+          entityId: 'workflow-789',
+          entityType: 'WORKFLOW',
+          page: 2,
+          perPage: 5,
+        });
+        expect(result).toEqual(mockResponse);
+        expect(global.fetch).toHaveBeenCalledWith(
+          `${clientOptions.baseUrl}/api/scores/entity/WORKFLOW/workflow-789?page=2&perPage=5`,
+          expect.objectContaining({
+            body: undefined,
+            headers: expect.objectContaining(clientOptions.headers),
+            signal: undefined,
+          }),
+        );
+      });
+    });
+
+    describe('saveScore()', () => {
+      it('should save a score', async () => {
+        const scoreData = {
+          id: 'score-1',
+          scorerId: 'test-scorer',
+          runId: 'run-123',
+          scorer: { name: 'test-scorer' },
+          score: 0.85,
+          input: [],
+          output: { response: 'test response' },
+          source: 'LIVE' as ScoringSource,
+          entityId: 'agent-456',
+          entityType: 'AGENT' as ScoringEntityType,
+          entity: { id: 'agent-456', name: 'test-agent' },
+          createdAt: new Date(),
+          updatedAt: new Date(),
+          runtimeContext: {
+            model: {
+              name: 'test-model',
+              version: '1.0.0',
+            },
+          },
+        };
+        const mockResponse = {
+          score: {
+            ...scoreData,
+            createdAt: scoreData.createdAt.toISOString(),
+            updatedAt: scoreData.updatedAt.toISOString(),
+          },
+        };
+        mockFetchResponse(mockResponse);
+
+        const result = await client.saveScore({ score: scoreData });
+        expect(result).toEqual({
+          score: {
+            ...scoreData,
+            createdAt: scoreData.createdAt.toISOString(),
+            updatedAt: scoreData.updatedAt.toISOString(),
+          },
+        });
+        expect(global.fetch).toHaveBeenCalledWith(
+          `${clientOptions.baseUrl}/api/scores`,
+          expect.objectContaining({
+            method: 'POST',
+            headers: expect.objectContaining(clientOptions.headers),
+            body: JSON.stringify({ score: scoreData }),
+          }),
+        );
+      });
+    });
+  });
 });

package/src/index.ts

@@ -1,2 +1,3 @@
 export * from './client';
 export * from './types';
+export type { UIMessageWithMetadata } from '@mastra/core/agent';

package/src/resources/a2a.ts

@@ -1,4 +1,12 @@
-import type { TaskSendParams, TaskQueryParams, TaskIdParams, Task, AgentCard, JSONRPCResponse } from '@mastra/core/a2a';
+import type {
+  AgentCard,
+  GetTaskResponse,
+  MessageSendParams,
+  SendMessageResponse,
+  SendStreamingMessageResponse,
+  Task,
+  TaskQueryParams,
+} from '@mastra/core/a2a';
 import type { ClientOptions } from '../types';
 import { BaseResource } from './base';
 
@@ -18,71 +26,73 @@ export class A2A extends BaseResource {
    * @returns Promise containing the agent card information
    */
   async getCard(): Promise<AgentCard> {
-    return this.request(`/.well-known/${this.agentId}/agent.json`);
+    return this.request(`/.well-known/${this.agentId}/agent-card.json`);
   }
 
   /**
-   * Send a message to the agent and get a response
+   * Send a message to the agent and gets a message or task response
    * @param params - Parameters for the task
-   * @returns Promise containing the task response
+   * @returns Promise containing the response
    */
-  async sendMessage(params: TaskSendParams): Promise<{ task: Task }> {
-    const response = await this.request<JSONRPCResponse<Task>>(`/a2a/${this.agentId}`, {
+  async sendMessage(params: MessageSendParams): Promise<SendMessageResponse> {
+    const response = await this.request<SendMessageResponse>(`/a2a/${this.agentId}`, {
       method: 'POST',
       body: {
-        method: 'tasks/send',
+        method: 'message/send',
         params,
       },
     });
 
-    return { task: response.result! };
+    return response;
   }
 
   /**
-   * Get the status and result of a task
-   * @param params - Parameters for querying the task
-   * @returns Promise containing the task response
+   * Sends a message to an agent to initiate/continue a task and subscribes
+   * the client to real-time updates for that task via Server-Sent Events (SSE).
+   * @param params - Parameters for the task
+   * @returns A stream of Server-Sent Events. Each SSE `data` field contains a `SendStreamingMessageResponse`
    */
-  async getTask(params: TaskQueryParams): Promise<Task> {
-    const response = await this.request<JSONRPCResponse<Task>>(`/a2a/${this.agentId}`, {
+  async sendStreamingMessage(params: MessageSendParams): Promise<AsyncIterable<SendStreamingMessageResponse>> {
+    const response = await this.request<AsyncIterable<SendStreamingMessageResponse>>(`/a2a/${this.agentId}`, {
       method: 'POST',
       body: {
-        method: 'tasks/get',
+        method: 'message/stream',
         params,
       },
     });
 
-    return response.result!;
+    return response;
   }
 
   /**
-   * Cancel a running task
-   * @param params - Parameters identifying the task to cancel
+   * Get the status and result of a task
+   * @param params - Parameters for querying the task
    * @returns Promise containing the task response
    */
-  async cancelTask(params: TaskIdParams): Promise<{ task: Task }> {
-    return this.request(`/a2a/${this.agentId}`, {
+  async getTask(params: TaskQueryParams): Promise<GetTaskResponse> {
+    const response = await this.request<GetTaskResponse>(`/a2a/${this.agentId}`, {
       method: 'POST',
       body: {
-        method: 'tasks/cancel',
+        method: 'tasks/get',
         params,
       },
     });
+
+    return response;
   }
 
   /**
-   * Send a message and subscribe to streaming updates (not fully implemented)
-   * @param params - Parameters for the task
+   * Cancel a running task
+   * @param params - Parameters identifying the task to cancel
    * @returns Promise containing the task response
    */
-  async sendAndSubscribe(params: TaskSendParams): Promise<Response> {
+  async cancelTask(params: TaskQueryParams): Promise<Task> {
     return this.request(`/a2a/${this.agentId}`, {
       method: 'POST',
       body: {
-        method: 'tasks/sendSubscribe',
+        method: 'tasks/cancel',
         params,
       },
-      stream: true,
     });
   }
 }