@mastra/client-js 0.0.0-tool-call-parts-20250630193309 → 0.0.0-transpile-packages-20250730132657

package/src/example.ts

@@ -14,25 +14,53 @@ import z from 'zod';
     const agent = client.getAgent('weatherAgent');
     const response = await agent.stream({
       messages: 'what is the weather in new york?',
+      output: z.object({
+        weather: z.string(),
+        temperature: z.number(),
+        humidity: z.number(),
+        windSpeed: z.number(),
+        windDirection: z.string(),
+        windGust: z.number(),
+        windChill: z.number(),
+      }),
     });
 
-    response.processDataStream({
-      onTextPart: text => {
-        process.stdout.write(text);
-      },
-      onFilePart: file => {
-        console.log(file);
-      },
-      onDataPart: data => {
-        console.log(data);
-      },
-      onErrorPart: error => {
-        console.error(error);
-      },
-      onToolCallPart(streamPart) {
-        console.log(streamPart);
-      },
-    });
+    // Process data stream - unstructured output
+
+    // response.processDataStream({
+    //   onTextPart: text => {
+    //     process.stdout.write(text);
+    //   },
+    //   onFilePart: file => {
+    //     console.log(file);
+    //   },
+    //   onDataPart: data => {
+    //     console.log(data);
+    //   },
+    //   onErrorPart: error => {
+    //     console.error(error);
+    //   },
+    //   onToolCallPart(streamPart) {
+    //     console.log(streamPart);
+    //   },
+    // });
+
+    // Process text stream - structured output
+
+    // response.processTextStream({
+    //   onTextPart: text => {
+    //     process.stdout.write(text);
+    //   },
+    // });
+
+    // read the response body directly
+
+    // const reader = response.body!.getReader();
+    // while (true) {
+    //   const { done, value } = await reader.read();
+    //   if (done) break;
+    //   console.log(new TextDecoder().decode(value));
+    // }
   } catch (error) {
     console.error(error);
   }

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,7 +306,7 @@ 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);
       }
     });
 
@@ -582,6 +590,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 +712,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 +877,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/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({
@@ -673,6 +685,24 @@ export class Agent extends BaseResource {
                   toolInvocation.result = result;
                 }
 
+                // write the tool result part to the stream
+                const writer = writable.getWriter();
+
+                try {
+                  await writer.write(
+                    new TextEncoder().encode(
+                      'a:' +
+                        JSON.stringify({
+                          toolCallId: toolCall.toolCallId,
+                          result,
+                        }) +
+                        '\n',
+                    ),
+                  );
+                } finally {
+                  writer.releaseLock();
+                }
+
                 // Convert messages to the correct format for the recursive call
                 const originalMessages = processedParams.messages;
                 const messageArray = Array.isArray(originalMessages) ? originalMessages : [originalMessages];

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,
         });

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,20 @@ 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()}`);
+  }
 }

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

@@ -10,6 +10,8 @@ import type {
 } from '../types';
 
 import { BaseResource } from './base';
+import { parseClientRuntimeContext } from '../utils';
+import type { RuntimeContext } from '@mastra/core/runtime-context';
 
 const RECORD_SEPARATOR = '\x1E';
 
@@ -37,7 +39,10 @@ export class VNextNetwork extends BaseResource {
   generate(params: GenerateOrStreamVNextNetworkParams): Promise<GenerateVNextNetworkResponse> {
     return this.request(`/api/networks/v-next/${this.networkId}/generate`, {
       method: 'POST',
-      body: params,
+      body: {
+        ...params,
+        runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      },
     });
   }
 
@@ -46,10 +51,16 @@ export class VNextNetwork extends BaseResource {
    * @param params - Generation parameters including message
    * @returns Promise containing the generated response
    */
-  loop(params: { message: string }): Promise<LoopVNextNetworkResponse> {
+  loop(params: {
+    message: string;
+    runtimeContext?: RuntimeContext | Record<string, any>;
+  }): Promise<LoopVNextNetworkResponse> {
     return this.request(`/api/networks/v-next/${this.networkId}/loop`, {
       method: 'POST',
-      body: params,
+      body: {
+        ...params,
+        runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      },
     });
   }
 
@@ -125,7 +136,10 @@ export class VNextNetwork extends BaseResource {
   async stream(params: GenerateOrStreamVNextNetworkParams, onRecord: (record: WatchEvent) => void) {
     const response: Response = await this.request(`/api/networks/v-next/${this.networkId}/stream`, {
       method: 'POST',
-      body: params,
+      body: {
+        ...params,
+        runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      },
       stream: true,
     });
 
@@ -154,7 +168,10 @@ export class VNextNetwork extends BaseResource {
   async loopStream(params: LoopStreamVNextNetworkParams, onRecord: (record: WatchEvent) => void) {
     const response: Response = await this.request(`/api/networks/v-next/${this.networkId}/loop-stream`, {
       method: 'POST',
-      body: params,
+      body: {
+        ...params,
+        runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      },
       stream: true,
     });