@mastra/client-js 0.0.0-fix-shareable-traces-20250717112558 → 0.0.0-fix-tool-call-history-20250730195323

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.0.0-fix-shareable-traces-20250717112558",
+  "version": "0.0.0-fix-tool-call-history-20250730195323",
   "description": "The official TypeScript library for the Mastra Client API",
   "author": "",
   "type": "module",
@@ -34,13 +34,13 @@
     "rxjs": "7.8.1",
     "zod": "^3.25.67",
     "zod-to-json-schema": "^3.24.5",
-    "@mastra/core": "0.0.0-fix-shareable-traces-20250717112558"
+    "@mastra/core": "0.0.0-fix-tool-call-history-20250730195323"
   },
   "peerDependencies": {
     "zod": "^3.0.0"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.27.2",
+    "@babel/preset-env": "^7.28.0",
     "@babel/preset-typescript": "^7.27.1",
     "@tsconfig/recommended": "^1.0.9",
     "@types/json-schema": "^7.0.15",
@@ -48,7 +48,7 @@
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
-    "@internal/lint": "0.0.0-fix-shareable-traces-20250717112558"
+    "@internal/lint": "0.0.0-fix-tool-call-history-20250730195323"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts --clean --treeshake=smallest --splitting",

package/src/client.ts

@@ -39,6 +39,13 @@ import type {
   GetNetworkMemoryThreadParams,
   CreateNetworkMemoryThreadParams,
   SaveNetworkMessageToMemoryParams,
+  GetScorerResponse,
+  GetScoresByScorerIdParams,
+  GetScoresResponse,
+  GetScoresByRunIdParams,
+  GetScoresByEntityIdParams,
+  SaveScoreParams,
+  SaveScoreResponse,
 } from './types';
 
 export class MastraClient extends BaseResource {
@@ -523,4 +530,94 @@ export class MastraClient extends BaseResource {
       },
     });
   }
+
+  /**
+   * Retrieves all available scorers
+   * @returns Promise containing list of available scorers
+   */
+  public getScorers(): Promise<Record<string, GetScorerResponse>> {
+    return this.request('/api/scores/scorers');
+  }
+
+  /**
+   * Retrieves a scorer by ID
+   * @param scorerId - ID of the scorer to retrieve
+   * @returns Promise containing the scorer
+   */
+  public getScorer(scorerId: string): Promise<GetScorerResponse> {
+    return this.request(`/api/scores/scorers/${scorerId}`);
+  }
+
+  public getScoresByScorerId(params: GetScoresByScorerIdParams): Promise<GetScoresResponse> {
+    const { page, perPage, scorerId, entityId, entityType } = params;
+    const searchParams = new URLSearchParams();
+
+    if (entityId) {
+      searchParams.set('entityId', entityId);
+    }
+    if (entityType) {
+      searchParams.set('entityType', entityType);
+    }
+
+    if (page !== undefined) {
+      searchParams.set('page', String(page));
+    }
+    if (perPage !== undefined) {
+      searchParams.set('perPage', String(perPage));
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/scores/scorer/${scorerId}${queryString ? `?${queryString}` : ''}`);
+  }
+
+  /**
+   * Retrieves scores by run ID
+   * @param params - Parameters containing run ID and pagination options
+   * @returns Promise containing scores and pagination info
+   */
+  public getScoresByRunId(params: GetScoresByRunIdParams): Promise<GetScoresResponse> {
+    const { runId, page, perPage } = params;
+    const searchParams = new URLSearchParams();
+
+    if (page !== undefined) {
+      searchParams.set('page', String(page));
+    }
+    if (perPage !== undefined) {
+      searchParams.set('perPage', String(perPage));
+    }
+
+    const queryString = searchParams.toString();
+    return this.request(`/api/scores/run/${runId}${queryString ? `?${queryString}` : ''}`);
+  }
+
+  /**
+   * Retrieves scores by entity ID and type
+   * @param params - Parameters containing entity ID, type, and pagination options
+   * @returns Promise containing scores and pagination info
+   */
+  public getScoresByEntityId(params: GetScoresByEntityIdParams): Promise<GetScoresResponse> {
+    const { entityId, entityType, page, perPage } = params;
+    const searchParams = new URLSearchParams();
+
+    if (page !== undefined) {
+      searchParams.set('page', String(page));
+    }
+    if (perPage !== undefined) {
+      searchParams.set('perPage', String(perPage));
+    }
+
+    const queryString = searchParams.toString();
+    return this.request(`/api/scores/entity/${entityType}/${entityId}${queryString ? `?${queryString}` : ''}`);
+  }
+
+  /**
+   * Saves a score
+   * @param params - Parameters containing the score data to save
+   * @returns Promise containing the saved score
+   */
+  public saveScore(params: SaveScoreParams): Promise<SaveScoreResponse> {
+    return this.request('/api/scores', {
+      method: 'POST',
+      body: params,
+    });
+  }
 }

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';