@mastra/client-js 0.1.11 → 0.1.12-alpha.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @mastra/client-js@0.1.11-alpha.1 build /home/runner/work/mastra/mastra/client-sdks/client-js
+> @mastra/client-js@0.1.12-alpha.0 build /home/runner/work/mastra/mastra/client-sdks/client-js
 > tsup src/index.ts --format esm,cjs --dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
@@ -9,11 +9,11 @@
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 19.41 KB
-ESM ⚡️ Build success in 800ms
-CJS dist/index.cjs 19.59 KB
-CJS ⚡️ Build success in 803ms
+ESM dist/index.js 21.01 KB
+ESM ⚡️ Build success in 777ms
+CJS dist/index.cjs 21.19 KB
+CJS ⚡️ Build success in 777ms
 DTS Build start
-DTS ⚡️ Build success in 9915ms
-DTS dist/index.d.ts  17.68 KB
-DTS dist/index.d.cts 17.68 KB
+DTS ⚡️ Build success in 9020ms
+DTS dist/index.d.ts  18.78 KB
+DTS dist/index.d.cts 18.78 KB

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @mastra/client-js
 
+## 0.1.12-alpha.0
+
+### Patch Changes
+
+- 05ef3e0: Support voice for mastra client
+- 248cb07: Allow ai-sdk Message type for messages in agent generate and stream
+  Fix sidebar horizontal overflow in playground
+- Updated dependencies [fb68a80]
+- Updated dependencies [b56a681]
+- Updated dependencies [248cb07]
+  - @mastra/core@0.6.4-alpha.0
+
 ## 0.1.11
 
 ### Patch Changes

package/dist/index.cjs

@@ -23,14 +23,15 @@ var BaseResource = class {
     let delay = backoffMs;
     for (let attempt = 0; attempt <= retries; attempt++) {
       try {
+        const defaultHeaders = options.body instanceof FormData ? {} : { "Content-Type": "application/json" };
         const response = await fetch(`${baseUrl}${path}`, {
           ...options,
           headers: {
-            "Content-Type": "application/json",
+            ...defaultHeaders,
             ...headers,
             ...options.headers
           },
-          body: options.body ? JSON.stringify(options.body) : void 0
+          body: options.body instanceof FormData ? options.body : options.body ? JSON.stringify(options.body) : void 0
         });
         if (!response.ok) {
           const errorBody = await response.text();
@@ -64,11 +65,60 @@ var BaseResource = class {
 };
 
 // src/resources/agent.ts
+var AgentVoice = class extends BaseResource {
+  constructor(options, agentId) {
+    super(options);
+    this.agentId = agentId;
+    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, options) {
+    return this.request(`/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, options) {
+    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() {
+    return this.request(`/api/agents/${this.agentId}/voice/speakers`);
+  }
+};
 var Agent = class extends BaseResource {
   constructor(options, agentId) {
     super(options);
     this.agentId = agentId;
+    this.voice = new AgentVoice(options, this.agentId);
   }
+  voice;
   /**
    * Retrieves details about the agent
    * @returns Promise containing agent details including model and instructions

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { CoreMessage, StorageThreadType, AiMessageType, MessageType, StepAction, StepGraph, QueryResult, BaseLogMessage, GenerateReturn } from '@mastra/core';
+import { CoreMessage, AiMessageType, StorageThreadType, MessageType, StepAction, StepGraph, QueryResult, BaseLogMessage, GenerateReturn } from '@mastra/core';
 import { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
 import { AgentGenerateOptions, AgentStreamOptions } from '@mastra/core/agent';
@@ -30,10 +30,10 @@ interface GetAgentResponse {
     modelId: string;
 }
 type GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
-    messages: string | string[] | CoreMessage[];
+    messages: string | string[] | CoreMessage[] | AiMessageType[];
 } & Partial<AgentGenerateOptions<T>>;
 type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
-    messages: string | string[] | CoreMessage[];
+    messages: string | string[] | CoreMessage[] | AiMessageType[];
 } & Partial<AgentStreamOptions<T>>;
 interface GetEvalsByAgentIdResponse extends GetAgentResponse {
     evals: any[];
@@ -174,8 +174,38 @@ declare class BaseResource {
     request<T>(path: string, options?: RequestOptions): Promise<T>;
 }
 
+declare class AgentVoice extends BaseResource {
+    private agentId;
+    constructor(options: ClientOptions, agentId: string);
+    /**
+     * 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
+     */
+    speak(text: string, options?: {
+        speaker?: string;
+        [key: string]: any;
+    }): Promise<Response>;
+    /**
+     * 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>;
+    /**
+     * Get available speakers for the agent's voice provider
+     * @returns Promise containing list of available speakers
+     */
+    getSpeakers(): Promise<Array<{
+        voiceId: string;
+        [key: string]: any;
+    }>>;
+}
 declare class Agent extends BaseResource {
     private agentId;
+    readonly voice: AgentVoice;
     constructor(options: ClientOptions, agentId: string);
     /**
      * Retrieves details about the agent

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { CoreMessage, StorageThreadType, AiMessageType, MessageType, StepAction, StepGraph, QueryResult, BaseLogMessage, GenerateReturn } from '@mastra/core';
+import { CoreMessage, AiMessageType, StorageThreadType, MessageType, StepAction, StepGraph, QueryResult, BaseLogMessage, GenerateReturn } from '@mastra/core';
 import { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
 import { AgentGenerateOptions, AgentStreamOptions } from '@mastra/core/agent';
@@ -30,10 +30,10 @@ interface GetAgentResponse {
     modelId: string;
 }
 type GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
-    messages: string | string[] | CoreMessage[];
+    messages: string | string[] | CoreMessage[] | AiMessageType[];
 } & Partial<AgentGenerateOptions<T>>;
 type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
-    messages: string | string[] | CoreMessage[];
+    messages: string | string[] | CoreMessage[] | AiMessageType[];
 } & Partial<AgentStreamOptions<T>>;
 interface GetEvalsByAgentIdResponse extends GetAgentResponse {
     evals: any[];
@@ -174,8 +174,38 @@ declare class BaseResource {
     request<T>(path: string, options?: RequestOptions): Promise<T>;
 }
 
+declare class AgentVoice extends BaseResource {
+    private agentId;
+    constructor(options: ClientOptions, agentId: string);
+    /**
+     * 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
+     */
+    speak(text: string, options?: {
+        speaker?: string;
+        [key: string]: any;
+    }): Promise<Response>;
+    /**
+     * 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>;
+    /**
+     * Get available speakers for the agent's voice provider
+     * @returns Promise containing list of available speakers
+     */
+    getSpeakers(): Promise<Array<{
+        voiceId: string;
+        [key: string]: any;
+    }>>;
+}
 declare class Agent extends BaseResource {
     private agentId;
+    readonly voice: AgentVoice;
     constructor(options: ClientOptions, agentId: string);
     /**
      * Retrieves details about the agent

package/dist/index.js

@@ -21,14 +21,15 @@ var BaseResource = class {
     let delay = backoffMs;
     for (let attempt = 0; attempt <= retries; attempt++) {
       try {
+        const defaultHeaders = options.body instanceof FormData ? {} : { "Content-Type": "application/json" };
         const response = await fetch(`${baseUrl}${path}`, {
           ...options,
           headers: {
-            "Content-Type": "application/json",
+            ...defaultHeaders,
             ...headers,
             ...options.headers
           },
-          body: options.body ? JSON.stringify(options.body) : void 0
+          body: options.body instanceof FormData ? options.body : options.body ? JSON.stringify(options.body) : void 0
         });
         if (!response.ok) {
           const errorBody = await response.text();
@@ -62,11 +63,60 @@ var BaseResource = class {
 };
 
 // src/resources/agent.ts
+var AgentVoice = class extends BaseResource {
+  constructor(options, agentId) {
+    super(options);
+    this.agentId = agentId;
+    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, options) {
+    return this.request(`/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, options) {
+    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() {
+    return this.request(`/api/agents/${this.agentId}/voice/speakers`);
+  }
+};
 var Agent = class extends BaseResource {
   constructor(options, agentId) {
     super(options);
     this.agentId = agentId;
+    this.voice = new AgentVoice(options, this.agentId);
   }
+  voice;
   /**
    * Retrieves details about the agent
    * @returns Promise containing agent details including model and instructions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.1.11",
+  "version": "0.1.12-alpha.0",
   "description": "The official TypeScript library for the Mastra Client API",
   "author": "",
   "type": "module",
@@ -25,7 +25,7 @@
     "json-schema": "^0.4.0",
     "zod": "^3.24.2",
     "zod-to-json-schema": "^3.24.3",
-    "@mastra/core": "^0.6.3"
+    "@mastra/core": "^0.6.4-alpha.0"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.26.9",

package/src/index.test.ts

@@ -18,27 +18,44 @@ describe('MastraClient Resources', () => {
   // 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: {},
           }),
         }),
@@ -333,6 +350,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', () => {

package/src/resources/agent.ts

@@ -36,12 +36,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);
   }
 
   /**

package/src/resources/base.ts

@@ -21,14 +21,19 @@ export class BaseResource {
 
     for (let attempt = 0; attempt <= retries; attempt++) {
       try {
+        const defaultHeaders: Record<string, string> =
+          options.body instanceof FormData
+            ? {} // Let browser set correct Content-Type for FormData which is required for audio
+            : { 'Content-Type': 'application/json' };
         const response = await fetch(`${baseUrl}${path}`, {
           ...options,
           headers: {
-            'Content-Type': 'application/json',
+            ...defaultHeaders,
             ...headers,
             ...options.headers,
           },
-          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/types.ts

@@ -44,11 +44,11 @@ export interface GetAgentResponse {
 }
 
 export type GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
-  messages: string | string[] | CoreMessage[];
+  messages: string | string[] | CoreMessage[] | AiMessageType[];
 } & Partial<AgentGenerateOptions<T>>;
 
 export type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
-  messages: string | string[] | CoreMessage[];
+  messages: string | string[] | CoreMessage[] | AiMessageType[];
 } & Partial<AgentStreamOptions<T>>;
 
 export interface GetEvalsByAgentIdResponse extends GetAgentResponse {