@mastra/client-js 0.0.0-transpile-packages-20250730132657 → 0.0.0-transpile-packages-20250731152758

package/dist/utils/zod-to-json-schema.d.ts

@@ -0,0 +1,105 @@
+import { ZodSchema } from 'zod';
+export declare function zodToJsonSchema<T extends ZodSchema | any>(zodSchema: T): T | ({
+    anyOf: import("zod-to-json-schema").JsonSchema7DateType[];
+} & {
+    title?: string;
+    default?: any;
+    description?: string;
+    markdownDescription?: string;
+} & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+    } | undefined;
+}) | ({
+    type: "object" | "array";
+} & {
+    title?: string;
+    default?: any;
+    description?: string;
+    markdownDescription?: string;
+} & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+    } | undefined;
+}) | ({
+    type: ("string" | "number" | "boolean" | "integer" | "null") | ("string" | "number" | "boolean" | "integer" | "null")[];
+} & {
+    title?: string;
+    default?: any;
+    description?: string;
+    markdownDescription?: string;
+} & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+    } | undefined;
+}) | ({
+    anyOf: import("zod-to-json-schema").JsonSchema7Type[];
+} & {
+    title?: string;
+    default?: any;
+    description?: string;
+    markdownDescription?: string;
+} & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+    } | undefined;
+}) | (import("zod-to-json-schema").JsonSchema7UndefinedType & {
+    title?: string;
+    default?: any;
+    description?: string;
+    markdownDescription?: string;
+} & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+    } | undefined;
+}) | (import("zod-to-json-schema").JsonSchema7AnyType & {
+    title?: string;
+    default?: any;
+    description?: string;
+    markdownDescription?: string;
+} & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+    } | undefined;
+}) | ({
+    anyOf: [import("zod-to-json-schema").JsonSchema7Type, import("zod-to-json-schema").JsonSchema7NullType];
+} & {
+    title?: string;
+    default?: any;
+    description?: string;
+    markdownDescription?: string;
+} & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+    } | undefined;
+}) | ({
+    type: [string, "null"];
+} & {
+    title?: string;
+    default?: any;
+    description?: string;
+    markdownDescription?: string;
+} & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+    } | undefined;
+}) | (import("zod-to-json-schema").JsonSchema7AllOfType & {
+    title?: string;
+    default?: any;
+    description?: string;
+    markdownDescription?: string;
+} & {
+    $schema?: string | undefined;
+    definitions?: {
+        [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+    } | undefined;
+});
+//# sourceMappingURL=zod-to-json-schema.d.ts.map

package/dist/utils/zod-to-json-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-to-json-schema.d.ts","sourceRoot":"","sources":["../../src/utils/zod-to-json-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAGhC,wBAAgB,eAAe,CAAC,CAAC,SAAS,SAAS,GAAG,GAAG,EAAE,SAAS,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAMtE"}

package/integration-tests/agui-adapter.test.ts

@@ -0,0 +1,122 @@
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:net';
+import path from 'node:path';
+import type { BaseEvent } from '@ag-ui/client';
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { AGUIAdapter } from '../src/adapters/agui';
+
+// Helper to find an available port
+async function getAvailablePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.listen(0, () => {
+      const { port } = server.address() as { port: number };
+      server.close(() => resolve(port));
+    });
+    server.on('error', reject);
+  });
+}
+
+describe('AGUIAdapter Integration Tests', () => {
+  let mastraServer: ReturnType<typeof spawn>;
+  let port: number;
+
+  beforeAll(async () => {
+    port = await getAvailablePort();
+
+    // Run mastra dev from the integration tests directory using the built CLI
+    const cliPath = path.resolve(import.meta.dirname, '..', '..', '..', 'packages', 'cli', 'dist', 'index.js');
+    mastraServer = spawn('node', [cliPath, 'dev', '--port', port.toString()], {
+      cwd: path.resolve(import.meta.dirname),
+      stdio: 'pipe',
+      detached: true, // Run in a new process group so we can kill it and children
+    });
+
+    // Wait for server to be ready
+    await new Promise<void>((resolve, reject) => {
+      let output = '';
+      mastraServer.stdout?.on('data', data => {
+        output += data.toString();
+        console.log(output);
+        if (output.includes('http://localhost:')) {
+          resolve();
+        }
+      });
+      mastraServer.stderr?.on('data', data => {
+        console.error('Mastra server error:', data.toString());
+      });
+
+      setTimeout(() => reject(new Error('Mastra server failed to start')), 10000);
+    });
+  });
+
+  afterAll(() => {
+    // Kill the server and its process group
+    if (mastraServer?.pid) {
+      try {
+        process.kill(-mastraServer.pid, 'SIGTERM');
+      } catch (e) {
+        console.error('Failed to kill Mastra server:', e);
+      }
+    }
+  });
+
+  it('should correctly pass parameters to agent stream method with real server', async () => {
+    // Create a client agent that communicates with the real server
+    const { Agent: ClientAgent } = await import('../src/resources/agent');
+    const clientAgent = new ClientAgent(
+      {
+        baseUrl: `http://localhost:${port}`,
+        apiKey: 'test-key',
+      },
+      'test',
+    );
+
+    const adapter = new AGUIAdapter({
+      agent: clientAgent,
+      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(7); // RUN_STARTED, TEXT_MESSAGE_START, TEXT_MESSAGE_CONTENT (x3), 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_CONTENT');
+    expect(events[4].type).toBe('TEXT_MESSAGE_CONTENT');
+    expect(events[5].type).toBe('TEXT_MESSAGE_END');
+    expect(events[6].type).toBe('RUN_FINISHED');
+
+    // Verify the content was streamed correctly
+    const contentEvents = events.filter(e => e.type === 'TEXT_MESSAGE_CONTENT') as any[];
+    expect(contentEvents[0].delta).toBe('Hello');
+    expect(contentEvents[1].delta).toBe(' from');
+    expect(contentEvents[2].delta).toBe(' agent');
+  });
+});

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-transpile-packages-20250730132657",
+  "version": "0.0.0-transpile-packages-20250731152758",
   "description": "The official TypeScript library for the Mastra Client API",
   "author": "",
   "type": "module",
@@ -27,32 +27,35 @@
   "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",
+    "@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.25.67",
     "zod-to-json-schema": "^3.24.5",
-    "@mastra/core": "0.0.0-transpile-packages-20250730132657"
+    "@mastra/core": "0.0.0-transpile-packages-20250731152758"
   },
   "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",
     "@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-transpile-packages-20250730132657"
+    "@internal/lint": "0.0.0-transpile-packages-20250731152758"
   },
   "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', () => {
@@ -178,3 +181,142 @@ describe('convertMessagesToMastraMessages', () => {
     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/index.test.ts

@@ -310,6 +310,114 @@ describe('MastraClient Resources', () => {
       }
     });
 
+    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',

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

@@ -632,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') {
@@ -711,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 {
@@ -724,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);