@mastra/client-js 0.0.0-storage-20250225005900 → 0.0.0-trigger-playground-ui-package-20250506151043

package/src/index.test.ts

@@ -1,4 +1,3 @@
-import type { MessageType } from '@mastra/core';
 import { describe, expect, beforeEach, it, vi } from 'vitest';
 
 import { MastraClient } from './client';
@@ -12,33 +11,51 @@ describe('MastraClient Resources', () => {
     baseUrl: 'http://localhost:4111',
     headers: {
       Authorization: 'Bearer test-key',
+      'x-mastra-client-type': 'js',
     },
   };
 
   // Helper to mock successful API responses
   const mockFetchResponse = (data: any, options: { isStream?: boolean } = {}) => {
     if (options.isStream) {
-      const stream = new ReadableStream({
-        start(controller) {
-          controller.enqueue(new TextEncoder().encode(JSON.stringify(data)));
-          controller.close();
-        },
-      });
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        headers: {
-          get: (name: string) => (name === 'Content-Type' ? 'text/event-stream' : null),
-        },
-        body: stream,
-      });
+      let contentType = 'text/event-stream';
+      let responseBody: ReadableStream;
+
+      if (data instanceof ReadableStream) {
+        responseBody = data;
+        contentType = 'audio/mp3';
+      } else {
+        responseBody = new ReadableStream({
+          start(controller) {
+            controller.enqueue(new TextEncoder().encode(JSON.stringify(data)));
+            controller.close();
+          },
+        });
+      }
+
+      const headers = new Headers();
+      if (contentType === 'audio/mp3') {
+        headers.set('Transfer-Encoding', 'chunked');
+      }
+      headers.set('Content-Type', contentType);
+
+      (global.fetch as any).mockResolvedValueOnce(
+        new Response(responseBody, {
+          status: 200,
+          statusText: 'OK',
+          headers,
+        }),
+      );
     } else {
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: true,
-        headers: {
-          get: (name: string) => (name === 'Content-Type' ? 'application/json' : null),
-        },
-        json: async () => data,
+      const response = new Response(undefined, {
+        status: 200,
+        statusText: 'OK',
+        headers: new Headers({
+          'Content-Type': 'application/json',
+        }),
       });
+      response.json = () => Promise.resolve(data);
+      (global.fetch as any).mockResolvedValueOnce(response);
     }
   };
 
@@ -241,7 +258,7 @@ describe('MastraClient Resources', () => {
       const result = await agent.generate({
         messages: [],
         threadId: 'test-thread',
-        resourceid: 'test-resource',
+        resourceId: 'test-resource',
         output: {},
       });
       expect(result).toEqual(mockResponse);
@@ -253,7 +270,7 @@ describe('MastraClient Resources', () => {
           body: JSON.stringify({
             messages: [],
             threadId: 'test-thread',
-            resourceid: 'test-resource',
+            resourceId: 'test-resource',
             output: {},
           }),
         }),
@@ -301,19 +318,18 @@ describe('MastraClient Resources', () => {
     });
 
     it('should get agent evals', async () => {
-      const mockResponse = {
-        name: 'Test Agent',
-        evals: [{ id: 'eval1' }],
-      };
+      const mockResponse = { data: 'test' };
       mockFetchResponse(mockResponse);
       const result = await agent.evals();
       expect(result).toEqual(mockResponse);
-      expect(global.fetch).toHaveBeenCalledWith(`${clientOptions.baseUrl}/api/agents/test-agent/evals/ci`, {
-        headers: {
-          Authorization: 'Bearer test-key',
-          'Content-Type': 'application/json',
-        },
-      });
+      expect(global.fetch).toHaveBeenCalledWith(
+        `${clientOptions.baseUrl}/api/agents/test-agent/evals/ci`,
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+        }),
+      );
     });
 
     it('should get live evals', async () => {
@@ -333,6 +349,106 @@ describe('MastraClient Resources', () => {
     });
   });
 
+  describe('Agent Voice Resource', () => {
+    const agentId = 'test-agent';
+    let agent: ReturnType<typeof client.getAgent>;
+    beforeEach(() => {
+      agent = client.getAgent(agentId);
+    });
+    it('should get available speakers', async () => {
+      const mockResponse = [{ voiceId: 'speaker1' }];
+      mockFetchResponse(mockResponse);
+
+      const result = await agent.voice.getSpeakers();
+
+      expect(result).toEqual(mockResponse);
+      expect(global.fetch).toHaveBeenCalledWith(
+        `${clientOptions.baseUrl}/api/agents/test-agent/voice/speakers`,
+        expect.objectContaining({
+          headers: expect.objectContaining(clientOptions.headers),
+        }),
+      );
+    });
+
+    it(`should call speak without options`, async () => {
+      const mockAudioStream = new ReadableStream();
+      mockFetchResponse(mockAudioStream, { isStream: true });
+
+      const result = await agent.voice.speak('test');
+
+      expect(result).toBeInstanceOf(Response);
+      expect(result.body).toBeInstanceOf(ReadableStream);
+      expect(global.fetch).toHaveBeenCalledWith(
+        `${clientOptions.baseUrl}/api/agents/test-agent/voice/speak`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining(clientOptions.headers),
+        }),
+      );
+    });
+
+    it(`should call speak with options`, async () => {
+      const mockAudioStream = new ReadableStream();
+      mockFetchResponse(mockAudioStream, { isStream: true });
+
+      const result = await agent.voice.speak('test', { speaker: 'speaker1' });
+      expect(result).toBeInstanceOf(Response);
+      expect(result.body).toBeInstanceOf(ReadableStream);
+      expect(global.fetch).toHaveBeenCalledWith(
+        `${clientOptions.baseUrl}/api/agents/test-agent/voice/speak`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining(clientOptions.headers),
+        }),
+      );
+    });
+
+    it(`should call listen with audio file`, async () => {
+      const transcriptionResponse = { text: 'Hello world' };
+      mockFetchResponse(transcriptionResponse);
+
+      const audioBlob = new Blob(['test audio data'], { type: 'audio/wav' });
+
+      const result = await agent.voice.listen(audioBlob, { filetype: 'wav' });
+      expect(result).toEqual(transcriptionResponse);
+
+      expect(global.fetch).toHaveBeenCalledTimes(1);
+      const [url, config] = (global.fetch as any).mock.calls[0];
+      expect(url).toBe(`${clientOptions.baseUrl}/api/agents/test-agent/voice/listen`);
+      expect(config.method).toBe('POST');
+      expect(config.headers).toMatchObject(clientOptions.headers);
+
+      const formData = config.body;
+      expect(formData).toBeInstanceOf(FormData);
+      const audioContent = formData.get('audio');
+      expect(audioContent).toBeInstanceOf(Blob);
+      expect(audioContent.type).toBe('audio/wav');
+    });
+
+    it(`should call listen with audio blob and options`, async () => {
+      const transcriptionResponse = { text: 'Hello world' };
+      mockFetchResponse(transcriptionResponse);
+
+      const audioBlob = new Blob(['test audio data'], { type: 'audio/mp3' });
+
+      const result = await agent.voice.listen(audioBlob, { filetype: 'mp3' });
+
+      expect(result).toEqual(transcriptionResponse);
+
+      expect(global.fetch).toHaveBeenCalledTimes(1);
+      const [url, config] = (global.fetch as any).mock.calls[0];
+      expect(url).toBe(`${clientOptions.baseUrl}/api/agents/test-agent/voice/listen`);
+      expect(config.method).toBe('POST');
+      expect(config.headers).toMatchObject(clientOptions.headers);
+
+      const formData = config.body as FormData;
+      expect(formData).toBeInstanceOf(FormData);
+      const audioContent = formData.get('audio');
+      expect(audioContent).toBeInstanceOf(Blob);
+      expect(formData.get('options')).toBe(JSON.stringify({ filetype: 'mp3' }));
+    });
+  });
+
   const agentId = 'test-agent';
 
   describe('Memory Thread Resource', () => {
@@ -372,7 +488,7 @@ describe('MastraClient Resources', () => {
       const result = await memoryThread.update({
         title: 'Updated Thread',
         metadata: { updated: true },
-        resourceid: 'test-resource',
+        resourceId: 'test-resource',
       });
       expect(result).toEqual(mockResponse);
       expect(global.fetch).toHaveBeenCalledWith(
@@ -412,29 +528,28 @@ describe('MastraClient Resources', () => {
     });
 
     it('should save messages to memory', async () => {
-      const messages: MessageType[] = [
+      const messages = [
         {
           id: '1',
-          type: 'text',
+          type: 'text' as const,
           content: 'test',
-          role: 'user',
+          role: 'user' as const,
           threadId: 'test-thread',
-          createdAt: new Date(),
+          resourceId: 'test-resource',
+          createdAt: new Date('2025-03-26T10:40:55.116Z'),
         },
       ];
       mockFetchResponse(messages);
-      const result = await client.saveMessageToMemory({ messages, agentId });
+      const result = await client.saveMessageToMemory({ agentId, messages });
       expect(result).toEqual(messages);
       expect(global.fetch).toHaveBeenCalledWith(
         `${clientOptions.baseUrl}/api/memory/save-messages?agentId=${agentId}`,
-        {
+        expect.objectContaining({
           method: 'POST',
-          headers: {
+          headers: expect.objectContaining({
             Authorization: 'Bearer test-key',
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify({ messages, agentId }),
-        },
+          }),
+        }),
       );
     });
   });
@@ -467,21 +582,19 @@ describe('MastraClient Resources', () => {
     });
 
     it('should execute tool', async () => {
-      const mockResponse = {
-        result: 'Tool execution result',
-      };
+      const mockResponse = { data: 'test' };
       mockFetchResponse(mockResponse);
-
-      const result = await tool.execute({ data: '' });
+      const result = await tool.execute({ data: '', runId: 'test-run-id' });
       expect(result).toEqual(mockResponse);
-      expect(global.fetch).toHaveBeenCalledWith(`${clientOptions.baseUrl}/api/tools/test-tool/execute`, {
-        method: 'POST',
-        headers: {
-          Authorization: 'Bearer test-key',
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ data: '' }),
-      });
+      expect(global.fetch).toHaveBeenCalledWith(
+        `${clientOptions.baseUrl}/api/tools/test-tool/execute?runId=test-run-id`,
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-key',
+          }),
+        }),
+      );
     });
   });
 
@@ -519,14 +632,14 @@ describe('MastraClient Resources', () => {
       };
       mockFetchResponse(mockResponse);
 
-      const result = await workflow.execute({ trigger: 'test' });
+      const result = await workflow.startAsync({ triggerData: { test: 'test' } });
       expect(result).toEqual(mockResponse);
       expect(global.fetch).toHaveBeenCalledWith(
-        `${clientOptions.baseUrl}/api/workflows/test-workflow/execute`,
+        `${clientOptions.baseUrl}/api/workflows/test-workflow/start-async?`,
         expect.objectContaining({
           method: 'POST',
           headers: expect.objectContaining(clientOptions.headers),
-          body: JSON.stringify({ trigger: 'test' }),
+          body: JSON.stringify({ test: 'test' }),
         }),
       );
     });

package/src/resources/agent.ts

@@ -1,4 +1,5 @@
-import type { GenerateReturn, StreamReturn } from '@mastra/core';
+import { processDataStream } from '@ai-sdk/ui-utils';
+import type { GenerateReturn } from '@mastra/core';
 import type { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
@@ -36,12 +37,70 @@ export class AgentTool extends BaseResource {
   }
 }
 
+export class AgentVoice extends BaseResource {
+  constructor(
+    options: ClientOptions,
+    private agentId: string,
+  ) {
+    super(options);
+    this.agentId = agentId;
+  }
+
+  /**
+   * Convert text to speech using the agent's voice provider
+   * @param text - Text to convert to speech
+   * @param options - Optional provider-specific options for speech generation
+   * @returns Promise containing the audio data
+   */
+  async speak(text: string, options?: { speaker?: string; [key: string]: any }): Promise<Response> {
+    return this.request<Response>(`/api/agents/${this.agentId}/voice/speak`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: { input: text, options },
+      stream: true,
+    });
+  }
+
+  /**
+   * Convert speech to text using the agent's voice provider
+   * @param audio - Audio data to transcribe
+   * @param options - Optional provider-specific options
+   * @returns Promise containing the transcribed text
+   */
+  listen(audio: Blob, options?: Record<string, any>): Promise<Response> {
+    const formData = new FormData();
+    formData.append('audio', audio);
+
+    if (options) {
+      formData.append('options', JSON.stringify(options));
+    }
+
+    return this.request(`/api/agents/${this.agentId}/voice/listen`, {
+      method: 'POST',
+      body: formData,
+    });
+  }
+
+  /**
+   * Get available speakers for the agent's voice provider
+   * @returns Promise containing list of available speakers
+   */
+  getSpeakers(): Promise<Array<{ voiceId: string; [key: string]: any }>> {
+    return this.request(`/api/agents/${this.agentId}/voice/speakers`);
+  }
+}
+
 export class Agent extends BaseResource {
+  public readonly voice: AgentVoice;
+
   constructor(
     options: ClientOptions,
     private agentId: string,
   ) {
     super(options);
+    this.voice = new AgentVoice(options, this.agentId);
   }
 
   /**
@@ -63,6 +122,10 @@ export class Agent extends BaseResource {
     const processedParams = {
       ...params,
       output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
+      experimental_output:
+        params.experimental_output instanceof ZodSchema
+          ? zodToJsonSchema(params.experimental_output)
+          : params.experimental_output,
     };
 
     return this.request(`/api/agents/${this.agentId}/generate`, {
@@ -74,19 +137,44 @@ export class Agent extends BaseResource {
   /**
    * Streams a response from the agent
    * @param params - Stream parameters including prompt
-   * @returns Promise containing the streamed response
+   * @returns Promise containing the enhanced Response object with processDataStream method
    */
-  stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: StreamParams<T>): Promise<Response> {
+  async stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(
+    params: StreamParams<T>,
+  ): Promise<
+    Response & {
+      processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
+    }
+  > {
     const processedParams = {
       ...params,
       output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
+      experimental_output:
+        params.experimental_output instanceof ZodSchema
+          ? zodToJsonSchema(params.experimental_output)
+          : params.experimental_output,
     };
 
-    return this.request(`/api/agents/${this.agentId}/stream`, {
+    const response: Response & {
+      processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
+    } = await this.request(`/api/agents/${this.agentId}/stream`, {
       method: 'POST',
       body: processedParams,
       stream: true,
     });
+
+    if (!response.body) {
+      throw new Error('No response body');
+    }
+
+    response.processDataStream = async (options = {}) => {
+      await processDataStream({
+        stream: response.body as ReadableStream<Uint8Array>,
+        ...options,
+      });
+    };
+
+    return response;
   }
 
   /**

package/src/resources/base.ts

@@ -1,4 +1,4 @@
-import type { RequestFunction, RequestOptions, ClientOptions } from '../types';
+import type { RequestOptions, ClientOptions } from '../types';
 
 export class BaseResource {
   readonly options: ClientOptions;
@@ -24,11 +24,13 @@ export class BaseResource {
         const response = await fetch(`${baseUrl}${path}`, {
           ...options,
           headers: {
-            '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',
           },
-          body: options.body ? JSON.stringify(options.body) : undefined,
+          body:
+            options.body instanceof FormData ? options.body : options.body ? JSON.stringify(options.body) : undefined,
         });
 
         if (!response.ok) {

package/src/resources/index.ts

@@ -1,6 +1,8 @@
 export * from './agent';
+export * from './network';
 export * from './memory-thread';
 export * from './vector';
 export * from './workflow';
 export * from './tool';
 export * from './base';
+export * from './vnext-workflow';

package/src/resources/memory-thread.ts

@@ -1,13 +1,6 @@
 import type { StorageThreadType } from '@mastra/core';
 
-import type {
-  CreateMemoryThreadParams,
-  GetMemoryThreadMessagesResponse,
-  GetMemoryThreadResponse,
-  ClientOptions,
-  SaveMessageToMemoryParams,
-  UpdateMemoryThreadParams,
-} from '../types';
+import type { GetMemoryThreadMessagesResponse, ClientOptions, UpdateMemoryThreadParams } from '../types';
 
 import { BaseResource } from './base';
 

package/src/resources/network.ts

@@ -0,0 +1,92 @@
+import { processDataStream } from '@ai-sdk/ui-utils';
+import type { GenerateReturn } from '@mastra/core';
+import type { JSONSchema7 } from 'json-schema';
+import { ZodSchema } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+import type { GenerateParams, ClientOptions, StreamParams, GetNetworkResponse } from '../types';
+
+import { BaseResource } from './base';
+
+export class Network extends BaseResource {
+  constructor(
+    options: ClientOptions,
+    private networkId: string,
+  ) {
+    super(options);
+  }
+
+  /**
+   * Retrieves details about the network
+   * @returns Promise containing network details
+   */
+  details(): Promise<GetNetworkResponse> {
+    return this.request(`/api/networks/${this.networkId}`);
+  }
+
+  /**
+   * Generates a response from the agent
+   * @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>> {
+    const processedParams = {
+      ...params,
+      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
+      experimental_output:
+        params.experimental_output instanceof ZodSchema
+          ? zodToJsonSchema(params.experimental_output)
+          : params.experimental_output,
+    };
+
+    return this.request(`/api/networks/${this.networkId}/generate`, {
+      method: 'POST',
+      body: processedParams,
+    });
+  }
+
+  /**
+   * Streams a response from the agent
+   * @param params - Stream parameters including prompt
+   * @returns Promise containing the enhanced Response object with processDataStream method
+   */
+  async stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(
+    params: StreamParams<T>,
+  ): Promise<
+    Response & {
+      processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
+    }
+  > {
+    const processedParams = {
+      ...params,
+      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
+      experimental_output:
+        params.experimental_output instanceof ZodSchema
+          ? zodToJsonSchema(params.experimental_output)
+          : params.experimental_output,
+    };
+
+    const response: Response & {
+      processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
+    } = await this.request(`/api/networks/${this.networkId}/stream`, {
+      method: 'POST',
+      body: processedParams,
+      stream: true,
+    });
+
+    if (!response.body) {
+      throw new Error('No response body');
+    }
+
+    response.processDataStream = async (options = {}) => {
+      await processDataStream({
+        stream: response.body as ReadableStream<Uint8Array>,
+        ...options,
+      });
+    };
+
+    return response;
+  }
+}

package/src/resources/tool.ts

@@ -23,10 +23,16 @@ export class Tool extends BaseResource {
    * @param params - Parameters required for tool execution
    * @returns Promise containing the tool execution results
    */
-  execute(params: { data: any }): Promise<any> {
-    return this.request(`/api/tools/${this.toolId}/execute`, {
+  execute(params: { data: any; runId?: string }): Promise<any> {
+    const url = new URLSearchParams();
+
+    if (params.runId) {
+      url.set('runId', params.runId);
+    }
+
+    return this.request(`/api/tools/${this.toolId}/execute?${url.toString()}`, {
       method: 'POST',
-      body: params,
+      body: params.data,
     });
   }
 }