@mastra/client-js 0.0.0-trigger-playground-ui-package-20250506151043 → 0.0.0-update-scorers-api-20250801170445

package/integration-tests/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@mastra/client-js-integration-tests",
+  "private": true,
+  "version": "0.1.0",
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@ag-ui/client": "^0.0.27",
+    "@mastra/client-js": "workspace:*",
+    "@mastra/core": "workspace:*",
+    "ai": "^4.3.19"
+  },
+  "devDependencies": {
+    "vitest": "^3.2.4"
+  }
+}

package/integration-tests/src/mastra/index.ts

@@ -0,0 +1,35 @@
+import { Mastra } from '@mastra/core';
+import { Agent } from '@mastra/core/agent';
+import { MockLanguageModelV1 } from 'ai/test';
+import { simulateReadableStream } from 'ai';
+
+const mockModel = new MockLanguageModelV1({
+  doStream: async () => ({
+    stream: simulateReadableStream({
+      chunks: [
+        { type: 'text-delta', textDelta: 'Hello' },
+        { type: 'text-delta', textDelta: ' from' },
+        { type: 'text-delta', textDelta: ' agent' },
+        {
+          type: 'finish',
+          finishReason: 'stop',
+          logprobs: undefined,
+          usage: { completionTokens: 3, promptTokens: 10 },
+        },
+      ],
+    }),
+    rawCall: { rawPrompt: null, rawSettings: {} },
+  }),
+});
+
+const testAgent = new Agent({
+  name: 'test',
+  instructions: 'You are a test agent',
+  model: mockModel,
+});
+
+export const mastra = new Mastra({
+  agents: {
+    test: testAgent,
+  },
+});

package/integration-tests/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    testTimeout: 30000, // 30 seconds for integration tests
+    hookTimeout: 20000, // 20 seconds for setup/teardown
+  },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.0.0-trigger-playground-ui-package-20250506151043",
+  "version": "0.0.0-update-scorers-api-20250801170445",
   "description": "The official TypeScript library for the Mastra Client API",
   "author": "",
   "type": "module",
@@ -19,34 +19,43 @@
     },
     "./package.json": "./package.json"
   },
-  "repository": "github:mastra-ai/client-js",
-  "license": "Elastic-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mastra-ai/mastra.git",
+    "directory": "client-sdks/client-js"
+  },
+  "homepage": "https://github.com/mastra-ai/mastra/tree/main/client-sdks/client-js#readme",
+  "license": "Apache-2.0",
   "dependencies": {
-    "@ag-ui/client": "^0.0.27",
-    "@ai-sdk/ui-utils": "^1.1.19",
+    "@ag-ui/client": "^0.0.35",
+    "@ai-sdk/ui-utils": "^1.2.11",
+    "@lukeed/uuid": "^2.0.1",
     "json-schema": "^0.4.0",
     "rxjs": "7.8.1",
-    "zod": "^3.24.2",
-    "zod-to-json-schema": "^3.24.3",
-    "@mastra/core": "0.0.0-trigger-playground-ui-package-20250506151043"
+    "zod": "^3.25.67",
+    "zod-to-json-schema": "^3.24.5",
+    "@mastra/core": "0.0.0-update-scorers-api-20250801170445"
   },
   "peerDependencies": {
-    "zod": "^3.24.2"
+    "zod": "^3.0.0"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.26.9",
-    "@babel/preset-typescript": "^7.27.0",
-    "@tsconfig/recommended": "^1.0.8",
+    "@babel/preset-env": "^7.28.0",
+    "@babel/preset-typescript": "^7.27.1",
+    "@tsconfig/recommended": "^1.0.9",
     "@types/json-schema": "^7.0.15",
-    "@types/node": "^20.17.27",
-    "tsup": "^8.4.0",
-    "typescript": "^5.8.2",
-    "vitest": "^3.1.2",
-    "@internal/lint": "0.0.0-trigger-playground-ui-package-20250506151043"
+    "@types/node": "^20.19.0",
+    "ai": "^4.3.19",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4",
+    "@internal/lint": "0.0.0-update-scorers-api-20250801170445"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --dts --clean --treeshake=smallest --splitting",
+    "build": "tsup --silent --config tsup.config.ts",
     "dev": "pnpm build --watch",
-    "test": "vitest run"
+    "test": "vitest run && pnpm run test:integration",
+    "test:unit": "vitest run",
+    "test:integration": "cd integration-tests && pnpm test"
   }
 }

package/src/adapters/agui.test.ts

@@ -1,6 +1,9 @@
-import type { Message } from '@ag-ui/client';
-import { describe, it, expect } from 'vitest';
-import { generateUUID, convertMessagesToMastraMessages } from './agui';
+import type { Message, BaseEvent } from '@ag-ui/client';
+import { describe, it, expect, vi } from 'vitest';
+import { generateUUID, convertMessagesToMastraMessages, AGUIAdapter } from './agui';
+import { Agent } from '@mastra/core/agent';
+import { MockLanguageModelV1 } from 'ai/test';
+import { simulateReadableStream } from 'ai';
 
 describe('generateUUID', () => {
   it('should generate a valid UUID v4 string', () => {
@@ -91,6 +94,17 @@ describe('convertMessagesToMastraMessages', () => {
           },
         ],
       },
+      {
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: 'tool-call-1',
+            toolName: 'getWeather',
+            result: { location: 'San Francisco' },
+          },
+        ],
+      },
     ]);
   });
 
@@ -143,12 +157,6 @@ describe('convertMessagesToMastraMessages', () => {
           },
         ],
       },
-      {
-        id: '3',
-        role: 'tool',
-        toolCallId: 'tool-call-1',
-        content: '{"temperature":72,"unit":"F"}',
-      },
       {
         id: '4',
         role: 'assistant',
@@ -162,6 +170,153 @@ describe('convertMessagesToMastraMessages', () => {
     expect(result[0].role).toBe('user');
     expect(result[1].role).toBe('assistant');
     expect(result[2].role).toBe('tool');
+    expect(result[2].content).toEqual([
+      {
+        type: 'tool-result',
+        toolCallId: 'tool-call-1',
+        toolName: 'getWeather',
+        result: { location: 'San Francisco' },
+      },
+    ]);
     expect(result[3].role).toBe('assistant');
   });
 });
+
+describe('AGUIAdapter', () => {
+  it('should correctly pass parameters to agent stream method', async () => {
+    // Create a real agent with MockLanguageModelV1
+    const mockModel = new MockLanguageModelV1({
+      doStream: async () => ({
+        stream: simulateReadableStream({
+          chunks: [
+            { type: 'text-delta', textDelta: 'Hello' },
+            { type: 'text-delta', textDelta: ' from' },
+            { type: 'text-delta', textDelta: ' agent' },
+            {
+              type: 'finish',
+              finishReason: 'stop',
+              logprobs: undefined,
+              usage: { completionTokens: 3, promptTokens: 10 },
+            },
+          ],
+        }),
+        rawCall: { rawPrompt: null, rawSettings: {} },
+      }),
+    });
+
+    const agent = new Agent({
+      name: 'Test Agent',
+      instructions: 'You are a test agent',
+      model: mockModel,
+    });
+
+    // Create a mock client agent that simulates the expected behavior
+    const clientAgent = {
+      stream: vi.fn().mockImplementation(async (params: any) => {
+        // Verify the parameters are passed correctly
+        expect(params).toHaveProperty('messages');
+        expect(params).toHaveProperty('threadId');
+        expect(params).toHaveProperty('resourceId');
+        expect(params).toHaveProperty('runId');
+        expect(params).toHaveProperty('clientTools');
+
+        // Verify that messages array is passed, not the entire request object
+        expect(Array.isArray(params.messages)).toBe(true);
+        expect(params.messages[0]).toHaveProperty('role');
+        expect(params.messages[0]).toHaveProperty('content');
+
+        // Return a mock processDataStream that mimics the expected behavior
+        return {
+          processDataStream: vi.fn().mockImplementation(async ({ onTextPart, onFinishMessagePart }: any) => {
+            // Simulate streaming text
+            if (onTextPart) {
+              onTextPart('Hello from agent');
+            }
+            if (onFinishMessagePart) {
+              onFinishMessagePart();
+            }
+            return Promise.resolve();
+          }),
+        };
+      }),
+    };
+
+    const adapter = new AGUIAdapter({
+      agent: clientAgent as any,
+      agentId: 'test',
+      resourceId: 'testAgent',
+    });
+
+    const input = {
+      threadId: 'test-thread-id',
+      runId: 'test-run-id',
+      messages: [
+        {
+          id: '1',
+          role: 'user' as const,
+          content: 'Hello',
+        },
+      ],
+      tools: [],
+      context: [],
+    };
+
+    const observable = adapter['run'](input);
+    const events: BaseEvent[] = [];
+
+    await new Promise<void>((resolve, reject) => {
+      observable.subscribe({
+        next: (event: BaseEvent) => events.push(event),
+        complete: () => resolve(),
+        error: (error: any) => reject(error),
+      });
+    });
+
+    // Verify we received the expected events
+    expect(events).toHaveLength(5); // RUN_STARTED, TEXT_MESSAGE_START, TEXT_MESSAGE_CONTENT, TEXT_MESSAGE_END, RUN_FINISHED
+    expect(events[0].type).toBe('RUN_STARTED');
+    expect(events[1].type).toBe('TEXT_MESSAGE_START');
+    expect(events[2].type).toBe('TEXT_MESSAGE_CONTENT');
+    expect(events[3].type).toBe('TEXT_MESSAGE_END');
+    expect(events[4].type).toBe('RUN_FINISHED');
+
+    // Verify the stream method was called with the correct parameters
+    expect(clientAgent.stream).toHaveBeenCalledWith({
+      threadId: 'test-thread-id',
+      resourceId: 'testAgent',
+      runId: 'test-run-id',
+      messages: [{ role: 'user', content: 'Hello' }],
+      clientTools: {},
+    });
+  });
+
+  it('should handle messages without role property in request objects', async () => {
+    // This test demonstrates that request objects without role property
+    // would cause validation errors if passed directly to MessageList
+    const requestObject = {
+      threadId: 'test-thread-id',
+      resourceId: 'testAgent',
+      runId: 'test-run-id',
+      messages: [
+        {
+          role: 'user',
+          content: 'Hello',
+        },
+      ],
+      clientTools: {},
+    };
+
+    // Request objects don't have role property
+    expect('role' in requestObject).toBe(false);
+    expect('messages' in requestObject).toBe(true);
+    expect('content' in requestObject).toBe(false);
+    expect('parts' in requestObject).toBe(false);
+
+    // This structure would cause validation errors if treated as a message
+    // because it lacks required message properties (role, content/parts)
+    const hasValidMessageStructure =
+      'role' in requestObject && ('content' in requestObject || 'parts' in requestObject);
+
+    expect(hasValidMessageStructure).toBe(false);
+  });
+});

package/src/adapters/agui.ts

@@ -1,19 +1,19 @@
 // Cross-platform UUID generation function
-import { AbstractAgent, EventType } from '@ag-ui/client';
 import type {
+  AgentConfig,
   BaseEvent,
+  Message,
   RunAgentInput,
-  AgentConfig,
-  RunStartedEvent,
   RunFinishedEvent,
-  TextMessageStartEvent,
+  RunStartedEvent,
   TextMessageContentEvent,
   TextMessageEndEvent,
-  Message,
-  ToolCallStartEvent,
+  TextMessageStartEvent,
   ToolCallArgsEvent,
   ToolCallEndEvent,
+  ToolCallStartEvent,
 } from '@ag-ui/client';
+import { AbstractAgent, EventType } from '@ag-ui/client';
 import type { CoreMessage } from '@mastra/core';
 import { Observable } from 'rxjs';
 import type { Agent } from '../resources/agent';
@@ -39,7 +39,6 @@ export class AGUIAdapter extends AbstractAgent {
   protected run(input: RunAgentInput): Observable<BaseEvent> {
     return new Observable<BaseEvent>(subscriber => {
       const convertedMessages = convertMessagesToMastraMessages(input.messages);
-
       subscriber.next({
         type: EventType.RUN_STARTED,
         threadId: input.threadId,
@@ -66,17 +65,18 @@ export class AGUIAdapter extends AbstractAgent {
         })
         .then(response => {
           let currentMessageId: string | undefined = undefined;
+          let isInTextMessage = false;
           return response.processDataStream({
             onTextPart: text => {
               if (currentMessageId === undefined) {
                 currentMessageId = generateUUID();
-
                 const message: TextMessageStartEvent = {
                   type: EventType.TEXT_MESSAGE_START,
                   messageId: currentMessageId,
                   role: 'assistant',
                 };
                 subscriber.next(message);
+                isInTextMessage = true;
               }
 
               const message: TextMessageContentEvent = {
@@ -86,14 +86,14 @@ export class AGUIAdapter extends AbstractAgent {
               };
               subscriber.next(message);
             },
-            onFinishMessagePart: message => {
-              console.log('onFinishMessagePart', message);
+            onFinishMessagePart: () => {
               if (currentMessageId !== undefined) {
                 const message: TextMessageEndEvent = {
                   type: EventType.TEXT_MESSAGE_END,
                   messageId: currentMessageId,
                 };
                 subscriber.next(message);
+                isInTextMessage = false;
               }
               // Emit run finished event
               subscriber.next({
@@ -107,6 +107,15 @@ export class AGUIAdapter extends AbstractAgent {
             },
             onToolCallPart(streamPart) {
               const parentMessageId = currentMessageId || generateUUID();
+              if (isInTextMessage) {
+                const message: TextMessageEndEvent = {
+                  type: EventType.TEXT_MESSAGE_END,
+                  messageId: parentMessageId,
+                };
+                subscriber.next(message);
+                isInTextMessage = false;
+              }
+
               subscriber.next({
                 type: EventType.TOOL_CALL_START,
                 toolCallId: streamPart.toolCallId,
@@ -130,7 +139,7 @@ export class AGUIAdapter extends AbstractAgent {
           });
         })
         .catch(error => {
-          console.log('error', error);
+          console.error('error', error);
           // Handle error
           subscriber.error(error);
         });
@@ -195,6 +204,17 @@ export function convertMessagesToMastraMessages(messages: Message[]): CoreMessag
         role: 'assistant',
         content: parts,
       });
+      if (message.toolCalls?.length) {
+        result.push({
+          role: 'tool',
+          content: message.toolCalls.map(toolCall => ({
+            type: 'tool-result',
+            toolCallId: toolCall.id,
+            toolName: toolCall.function.name,
+            result: JSON.parse(toolCall.function.arguments),
+          })),
+        });
+      }
     } else if (message.role === 'user') {
       result.push({
         role: 'user',