@mastra/client-js 0.0.0-tsconfig-compile-20250703214351 → 0.0.0-update-scorers-api-20250801170445

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/agent.ts

@@ -9,11 +9,13 @@ import {
   type UIMessage,
   type UseChatOptions,
 } from '@ai-sdk/ui-utils';
-import { Tool, type CoreMessage, type GenerateReturn } from '@mastra/core';
+import { Tool, type CoreMessage } from '@mastra/core';
+import { type GenerateReturn } from '@mastra/core/llm';
 import type { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
 import { zodToJsonSchema } from '../utils/zod-to-json-schema';
 import { processClientTools } from '../utils/process-client-tools';
+import { v4 as uuid } from '@lukeed/uuid';
 
 import type {
   GenerateParams,
@@ -116,18 +118,19 @@ export class Agent extends BaseResource {
    * @param params - Generation parameters including prompt
    * @returns Promise containing the generated response
    */
-  async generate<T extends JSONSchema7 | ZodSchema | undefined = undefined>(
-    params: GenerateParams<T> & { output?: never; experimental_output?: never },
-  ): Promise<GenerateReturn<T>>;
-  async generate<T extends JSONSchema7 | ZodSchema | undefined = undefined>(
-    params: GenerateParams<T> & { output: T; experimental_output?: never },
-  ): Promise<GenerateReturn<T>>;
-  async generate<T extends JSONSchema7 | ZodSchema | undefined = undefined>(
-    params: GenerateParams<T> & { output?: never; experimental_output: T },
-  ): Promise<GenerateReturn<T>>;
-  async generate<T extends JSONSchema7 | ZodSchema | undefined = undefined>(
-    params: GenerateParams<T>,
-  ): Promise<GenerateReturn<T>> {
+  async generate(
+    params: GenerateParams<undefined> & { output?: never; experimental_output?: never },
+  ): Promise<GenerateReturn<any, undefined, undefined>>;
+  async generate<Output extends JSONSchema7 | ZodSchema>(
+    params: GenerateParams<Output> & { output: Output; experimental_output?: never },
+  ): Promise<GenerateReturn<any, Output, undefined>>;
+  async generate<StructuredOutput extends JSONSchema7 | ZodSchema>(
+    params: GenerateParams<StructuredOutput> & { output?: never; experimental_output: StructuredOutput },
+  ): Promise<GenerateReturn<any, undefined, StructuredOutput>>;
+  async 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: params.output ? zodToJsonSchema(params.output) : undefined,
@@ -138,18 +141,27 @@ export class Agent extends BaseResource {
 
     const { runId, resourceId, threadId, runtimeContext } = processedParams as GenerateParams;
 
-    const response: GenerateReturn<T> = await this.request(`/api/agents/${this.agentId}/generate`, {
-      method: 'POST',
-      body: processedParams,
-    });
+    const response: GenerateReturn<any, Output, StructuredOutput> = await this.request(
+      `/api/agents/${this.agentId}/generate`,
+      {
+        method: 'POST',
+        body: processedParams,
+      },
+    );
 
     if (response.finishReason === 'tool-calls') {
-      for (const toolCall of (
+      const toolCalls = (
         response as unknown as {
           toolCalls: { toolName: string; args: any; toolCallId: string }[];
           messages: CoreMessage[];
         }
-      ).toolCalls) {
+      ).toolCalls;
+
+      if (!toolCalls || !Array.isArray(toolCalls)) {
+        return response;
+      }
+
+      for (const toolCall of toolCalls) {
         const clientTool = params.clientTools?.[toolCall.toolName] as Tool;
 
         if (clientTool && clientTool.execute) {
@@ -219,7 +231,7 @@ export class Agent extends BaseResource {
     const message: UIMessage = replaceLastMessage
       ? structuredClone(lastMessage)
       : {
-          id: crypto.randomUUID(),
+          id: uuid(),
           createdAt: getCurrentDate(),
           role: 'assistant',
           content: '',
@@ -279,7 +291,7 @@ export class Agent extends BaseResource {
         // changes. This is why we need to add a revision id to ensure that the message
         // is updated with SWR (without it, the changes get stuck in SWR and are not
         // forwarded to rendering):
-        revisionId: crypto.randomUUID(),
+        revisionId: uuid(),
       } as UIMessage;
 
       update({
@@ -620,7 +632,13 @@ export class Agent extends BaseResource {
       this.processChatResponse({
         stream: streamForProcessing,
         update: ({ message }) => {
-          messages.push(message);
+          const existingIndex = messages.findIndex(m => m.id === message.id);
+
+          if (existingIndex !== -1) {
+            messages[existingIndex] = message;
+          } else {
+            messages.push(message);
+          }
         },
         onFinish: async ({ finishReason, message }) => {
           if (finishReason === 'tool-calls') {
@@ -699,10 +717,12 @@ export class Agent extends BaseResource {
                 this.processStreamResponse(
                   {
                     ...processedParams,
-                    messages: [...messageArray, ...messages, lastMessage],
+                    messages: [...messageArray, ...messages.filter(m => m.id !== lastMessage.id), lastMessage],
                   },
                   writable,
-                );
+                ).catch(error => {
+                  console.error('Error processing stream response:', error);
+                });
               }
             }
           } else {
@@ -712,6 +732,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/base.ts

@@ -24,12 +24,17 @@ 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
             // 'x-mastra-client-type': 'js',
           },
+          signal: this.options.abortSignal,
           body:
             options.body instanceof FormData ? options.body : options.body ? JSON.stringify(options.body) : undefined,
         });