@mastra/client-js 0.0.0-working-memory-per-user-20250620163010 → 0.0.0-zod-v4-compat-part-2-20250822105954

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.0.0-working-memory-per-user-20250620163010",
+  "version": "0.0.0-zod-v4-compat-part-2-20250822105954",
   "description": "The official TypeScript library for the Mastra Client API",
   "author": "",
   "type": "module",
@@ -25,33 +25,37 @@
     "directory": "client-sdks/client-js"
   },
   "homepage": "https://github.com/mastra-ai/mastra/tree/main/client-sdks/client-js#readme",
-  "license": "Elastic-2.0",
+  "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.57",
     "zod-to-json-schema": "^3.24.5",
-    "@mastra/core": "0.0.0-working-memory-per-user-20250620163010"
+    "@mastra/core": "0.0.0-zod-v4-compat-part-2-20250822105954"
   },
   "peerDependencies": {
-    "zod": "^3.0.0"
+    "zod": "^3.0.0 || ^4.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.8",
+    "@tsconfig/recommended": "^1.0.9",
     "@types/json-schema": "^7.0.15",
     "@types/node": "^20.19.0",
+    "zod": "^3.25.67",
+    "ai": "^4.3.19",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.3",
-    "@internal/lint": "0.0.0-working-memory-per-user-20250620163010"
+    "vitest": "^3.2.4",
+    "@internal/lint": "0.0.0-zod-v4-compat-part-2-20250822105954"
   },
   "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/client.ts

@@ -13,6 +13,8 @@ import {
   MCPTool,
   LegacyWorkflow,
 } from './resources';
+import { NetworkMemoryThread } from './resources/network-memory-thread';
+import { VNextNetwork } from './resources/vNextNetwork';
 import type {
   ClientOptions,
   CreateMemoryThreadParams,
@@ -33,6 +35,17 @@ import type {
   McpServerListResponse,
   McpServerToolListResponse,
   GetLegacyWorkflowResponse,
+  GetVNextNetworkResponse,
+  GetNetworkMemoryThreadParams,
+  CreateNetworkMemoryThreadParams,
+  SaveNetworkMessageToMemoryParams,
+  GetScorerResponse,
+  GetScoresByScorerIdParams,
+  GetScoresResponse,
+  GetScoresByRunIdParams,
+  GetScoresByEntityIdParams,
+  SaveScoreParams,
+  SaveScoreResponse,
 } from './types';
 
 export class MastraClient extends BaseResource {
@@ -123,6 +136,53 @@ export class MastraClient extends BaseResource {
     return this.request(`/api/memory/status?agentId=${agentId}`);
   }
 
+  /**
+   * Retrieves memory threads for a resource
+   * @param params - Parameters containing the resource ID
+   * @returns Promise containing array of memory threads
+   */
+  public getNetworkMemoryThreads(params: GetNetworkMemoryThreadParams): Promise<GetMemoryThreadResponse> {
+    return this.request(`/api/memory/network/threads?resourceid=${params.resourceId}&networkId=${params.networkId}`);
+  }
+
+  /**
+   * Creates a new memory thread
+   * @param params - Parameters for creating the memory thread
+   * @returns Promise containing the created memory thread
+   */
+  public createNetworkMemoryThread(params: CreateNetworkMemoryThreadParams): Promise<CreateMemoryThreadResponse> {
+    return this.request(`/api/memory/network/threads?networkId=${params.networkId}`, { method: 'POST', body: params });
+  }
+
+  /**
+   * Gets a memory thread instance by ID
+   * @param threadId - ID of the memory thread to retrieve
+   * @returns MemoryThread instance
+   */
+  public getNetworkMemoryThread(threadId: string, networkId: string) {
+    return new NetworkMemoryThread(this.options, threadId, networkId);
+  }
+
+  /**
+   * Saves messages to memory
+   * @param params - Parameters containing messages to save
+   * @returns Promise containing the saved messages
+   */
+  public saveNetworkMessageToMemory(params: SaveNetworkMessageToMemoryParams): Promise<SaveMessageToMemoryResponse> {
+    return this.request(`/api/memory/network/save-messages?networkId=${params.networkId}`, {
+      method: 'POST',
+      body: params,
+    });
+  }
+
+  /**
+   * Gets the status of the memory system
+   * @returns Promise containing memory system status
+   */
+  public getNetworkMemoryStatus(networkId: string): Promise<{ result: boolean }> {
+    return this.request(`/api/memory/network/status?networkId=${networkId}`);
+  }
+
   /**
    * Retrieves all available tools
    * @returns Promise containing map of tool IDs to tool details
@@ -334,10 +394,18 @@ export class MastraClient extends BaseResource {
    * Retrieves all available networks
    * @returns Promise containing map of network IDs to network details
    */
-  public getNetworks(): Promise<Record<string, GetNetworkResponse>> {
+  public getNetworks(): Promise<Array<GetNetworkResponse>> {
     return this.request('/api/networks');
   }
 
+  /**
+   * Retrieves all available vNext networks
+   * @returns Promise containing map of vNext network IDs to vNext network details
+   */
+  public getVNextNetworks(): Promise<Array<GetVNextNetworkResponse>> {
+    return this.request('/api/networks/v-next');
+  }
+
   /**
    * Gets a network instance by ID
    * @param networkId - ID of the network to retrieve
@@ -347,6 +415,15 @@ export class MastraClient extends BaseResource {
     return new Network(this.options, networkId);
   }
 
+  /**
+   * Gets a vNext network instance by ID
+   * @param networkId - ID of the vNext network to retrieve
+   * @returns vNext Network instance
+   */
+  public getVNextNetwork(networkId: string) {
+    return new VNextNetwork(this.options, networkId);
+  }
+
   /**
    * Retrieves a list of available MCP servers.
    * @param params - Optional parameters for pagination (limit, offset).
@@ -407,4 +484,140 @@ export class MastraClient extends BaseResource {
   public getA2A(agentId: string) {
     return new A2A(this.options, agentId);
   }
+
+  /**
+   * Retrieves the working memory for a specific thread (optionally resource-scoped).
+   * @param agentId - ID of the agent.
+   * @param threadId - ID of the thread.
+   * @param resourceId - Optional ID of the resource.
+   * @returns Working memory for the specified thread or resource.
+   */
+  public getWorkingMemory({
+    agentId,
+    threadId,
+    resourceId,
+  }: {
+    agentId: string;
+    threadId: string;
+    resourceId?: string;
+  }) {
+    return this.request(`/api/memory/threads/${threadId}/working-memory?agentId=${agentId}&resourceId=${resourceId}`);
+  }
+
+  /**
+   * Updates the working memory for a specific thread (optionally resource-scoped).
+   * @param agentId - ID of the agent.
+   * @param threadId - ID of the thread.
+   * @param workingMemory - The new working memory content.
+   * @param resourceId - Optional ID of the resource.
+   */
+  public updateWorkingMemory({
+    agentId,
+    threadId,
+    workingMemory,
+    resourceId,
+  }: {
+    agentId: string;
+    threadId: string;
+    workingMemory: string;
+    resourceId?: string;
+  }) {
+    return this.request(`/api/memory/threads/${threadId}/working-memory?agentId=${agentId}`, {
+      method: 'POST',
+      body: {
+        workingMemory,
+        resourceId,
+      },
+    });
+  }
+
+  /**
+   * 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/example.ts

@@ -1,8 +1,8 @@
 import { MastraClient } from './client';
+import z from 'zod';
 // import type { WorkflowRunResult } from './types';
 
 // Agent
-
 (async () => {
   const client = new MastraClient({
     baseUrl: 'http://localhost:4111',
@@ -14,22 +14,53 @@ import { MastraClient } from './client';
     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);
-      },
-    });
+    // 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);
   }