@mastra/client-js 0.0.0-storage-20250225005900 → 0.0.0-taofeeqInngest-20250603090617

package/src/example.ts

@@ -1,43 +1,64 @@
 import { MastraClient } from './client';
+// import type { WorkflowRunResult } from './types';
+
+// Agent
 
 (async () => {
   const client = new MastraClient({
     baseUrl: 'http://localhost:4111',
   });
 
+  console.log('Starting agent...');
+
   try {
     const agent = client.getAgent('weatherAgent');
     const response = await agent.stream({
-      messages: [
-        {
-          role: 'user',
-          content: 'Hello, world!',
-        },
-      ],
+      messages: 'what is the weather in new york?',
+    });
+
+    response.processDataStream({
+      onTextPart: text => {
+        process.stdout.write(text);
+      },
+      onFilePart: file => {
+        console.log(file);
+      },
+      onDataPart: data => {
+        console.log(data);
+      },
+      onErrorPart: error => {
+        console.error(error);
+      },
     });
+  } catch (error) {
+    console.error(error);
+  }
+})();
 
-    const reader = response?.body?.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
+// Workflow
+// (async () => {
+//   const client = new MastraClient({
+//     baseUrl: 'http://localhost:4111',
+//   });
 
-    while (true) {
-      if (!reader) break;
-      const { value, done } = await reader.read();
-      if (done) break;
+//   try {
+//     const workflowId = 'myWorkflow';
+//     const workflow = client.getWorkflow(workflowId);
 
-      const chunk = decoder.decode(value);
-      buffer += chunk;
+//     const { runId } = await workflow.createRun();
 
-      console.log(buffer);
+//     workflow.watch({ runId }, record => {
+//       console.log(new Date().toTimeString(), record);
+//     });
 
-      const matches = buffer.matchAll(/0:"([^"]*)"/g);
+//     await workflow.start({
+//       runId,
+//       triggerData: {
+//         city: 'New York',
+//       },
+//     });
 
-      for (const match of matches) {
-        const content = match[1];
-        process.stdout.write(`${content}\n`);
-      }
-    }
-  } catch (error) {
-    console.error(error);
-  }
-})();
+//   } catch (e) {
+//     console.error('Workflow error:', e);
+//   }
+// })();

package/src/index.test.ts

@@ -1,7 +1,6 @@
-import type { MessageType } from '@mastra/core';
 import { describe, expect, beforeEach, it, vi } from 'vitest';
-
 import { MastraClient } from './client';
+import type { McpServerListResponse, ServerDetailInfo } from './types';
 
 // Mock fetch globally
 global.fetch = vi.fn();
@@ -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);
     }
   };
 
@@ -219,6 +236,7 @@ describe('MastraClient Resources', () => {
         model: 'gpt-4',
         instructions: 'Test instructions',
         tools: {},
+        workflows: {},
       };
       mockFetchResponse(mockResponse);
 
@@ -241,7 +259,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 +271,7 @@ describe('MastraClient Resources', () => {
           body: JSON.stringify({
             messages: [],
             threadId: 'test-thread',
-            resourceid: 'test-resource',
+            resourceId: 'test-resource',
             output: {},
           }),
         }),
@@ -301,19 +319,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 +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', () => {
@@ -372,7 +489,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 +529,57 @@ 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',
+          }),
+        }),
+      );
+    });
+
+    it('should get thread messages with limit', async () => {
+      const mockResponse = {
+        messages: [
+          {
+            id: '1',
+            content: 'test',
+            threadId,
+            role: 'user',
+            type: 'text',
+            resourceId: 'test-resource',
+            createdAt: new Date(),
           },
-          body: JSON.stringify({ messages, agentId }),
-        },
+        ],
+        uiMessages: [],
+      };
+      mockFetchResponse(mockResponse);
+
+      const limit = 5;
+      const result = await memoryThread.getMessages({ limit });
+
+      expect(result).toEqual(mockResponse);
+      expect(global.fetch).toHaveBeenCalledWith(
+        `${clientOptions.baseUrl}/api/memory/threads/${threadId}/messages?agentId=${agentId}&limit=${limit}`,
+        expect.objectContaining({
+          headers: expect.objectContaining(clientOptions.headers),
+        }),
       );
     });
   });
@@ -467,21 +612,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 +662,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' }),
         }),
       );
     });
@@ -594,4 +737,94 @@ describe('MastraClient Resources', () => {
       );
     });
   });
+
+  describe('MCP Server Registry Client Methods', () => {
+    const mockServerInfo1 = {
+      id: 'mcp-server-1',
+      name: 'Test MCP Server 1',
+      version_detail: { version: '1.0.0', release_date: '2023-01-01T00:00:00Z', is_latest: true },
+    };
+    const mockServerInfo2 = {
+      id: 'mcp-server-2',
+      name: 'Test MCP Server 2',
+      version_detail: { version: '1.1.0', release_date: '2023-02-01T00:00:00Z', is_latest: true },
+    };
+
+    const mockServerDetail1: ServerDetailInfo = {
+      ...mockServerInfo1,
+      description: 'Detailed description for server 1',
+      package_canonical: 'npm',
+      packages: [{ registry_name: 'npm', name: '@example/server1', version: '1.0.0' }],
+      remotes: [{ transport_type: 'sse', url: 'http://localhost/sse1' }],
+    };
+
+    describe('getMcpServers()', () => {
+      it('should fetch a list of MCP servers', async () => {
+        const mockResponse: McpServerListResponse = {
+          servers: [mockServerInfo1, mockServerInfo2],
+          total_count: 2,
+          next: null,
+        };
+        mockFetchResponse(mockResponse);
+
+        const result = await client.getMcpServers();
+        expect(result).toEqual(mockResponse);
+        expect(global.fetch).toHaveBeenCalledWith(
+          `${clientOptions.baseUrl}/api/mcp/v0/servers`,
+          expect.objectContaining({
+            headers: expect.objectContaining(clientOptions.headers),
+          }),
+        );
+      });
+
+      it('should fetch MCP servers with limit and offset parameters', async () => {
+        const mockResponse: McpServerListResponse = {
+          servers: [mockServerInfo1],
+          total_count: 2,
+          next: '/api/mcp/v0/servers?limit=1&offset=1',
+        };
+        mockFetchResponse(mockResponse);
+
+        const result = await client.getMcpServers({ limit: 1, offset: 0 });
+        expect(result).toEqual(mockResponse);
+        expect(global.fetch).toHaveBeenCalledWith(
+          `${clientOptions.baseUrl}/api/mcp/v0/servers?limit=1&offset=0`,
+          expect.objectContaining({
+            headers: expect.objectContaining(clientOptions.headers),
+          }),
+        );
+      });
+    });
+
+    describe('getMcpServerDetails()', () => {
+      const serverId = 'mcp-server-1';
+
+      it('should fetch details for a specific MCP server', async () => {
+        mockFetchResponse(mockServerDetail1);
+
+        const result = await client.getMcpServerDetails(serverId);
+        expect(result).toEqual(mockServerDetail1);
+        expect(global.fetch).toHaveBeenCalledWith(
+          `${clientOptions.baseUrl}/api/mcp/v0/servers/${serverId}`,
+          expect.objectContaining({
+            headers: expect.objectContaining(clientOptions.headers),
+          }),
+        );
+      });
+
+      it('should fetch MCP server details with a version parameter', async () => {
+        mockFetchResponse(mockServerDetail1);
+        const version = '1.0.0';
+
+        const result = await client.getMcpServerDetails(serverId, { version });
+        expect(result).toEqual(mockServerDetail1);
+        expect(global.fetch).toHaveBeenCalledWith(
+          `${clientOptions.baseUrl}/api/mcp/v0/servers/${serverId}?version=${version}`,
+          expect.objectContaining({
+            headers: expect.objectContaining(clientOptions.headers),
+          }),
+        );
+      });
+    });
+  });
 });

package/src/resources/a2a.ts

@@ -0,0 +1,88 @@
+import type { TaskSendParams, TaskQueryParams, TaskIdParams, Task, AgentCard, JSONRPCResponse } from '@mastra/core/a2a';
+import type { ClientOptions } from '../types';
+import { BaseResource } from './base';
+
+/**
+ * Class for interacting with an agent via the A2A protocol
+ */
+export class A2A extends BaseResource {
+  constructor(
+    options: ClientOptions,
+    private agentId: string,
+  ) {
+    super(options);
+  }
+
+  /**
+   * Get the agent card with metadata about the agent
+   * @returns Promise containing the agent card information
+   */
+  async getCard(): Promise<AgentCard> {
+    return this.request(`/.well-known/${this.agentId}/agent.json`);
+  }
+
+  /**
+   * Send a message to the agent and get a response
+   * @param params - Parameters for the task
+   * @returns Promise containing the task response
+   */
+  async sendMessage(params: TaskSendParams): Promise<{ task: Task }> {
+    const response = await this.request<JSONRPCResponse<Task>>(`/a2a/${this.agentId}`, {
+      method: 'POST',
+      body: {
+        method: 'tasks/send',
+        params,
+      },
+    });
+
+    return { task: response.result! };
+  }
+
+  /**
+   * Get the status and result of a task
+   * @param params - Parameters for querying the task
+   * @returns Promise containing the task response
+   */
+  async getTask(params: TaskQueryParams): Promise<Task> {
+    const response = await this.request<JSONRPCResponse<Task>>(`/a2a/${this.agentId}`, {
+      method: 'POST',
+      body: {
+        method: 'tasks/get',
+        params,
+      },
+    });
+
+    return response.result!;
+  }
+
+  /**
+   * Cancel a running task
+   * @param params - Parameters identifying the task to cancel
+   * @returns Promise containing the task response
+   */
+  async cancelTask(params: TaskIdParams): Promise<{ task: Task }> {
+    return this.request(`/a2a/${this.agentId}`, {
+      method: 'POST',
+      body: {
+        method: 'tasks/cancel',
+        params,
+      },
+    });
+  }
+
+  /**
+   * Send a message and subscribe to streaming updates (not fully implemented)
+   * @param params - Parameters for the task
+   * @returns Promise containing the task response
+   */
+  async sendAndSubscribe(params: TaskSendParams): Promise<Response> {
+    return this.request(`/a2a/${this.agentId}`, {
+      method: 'POST',
+      body: {
+        method: 'tasks/sendSubscribe',
+        params,
+      },
+      stream: true,
+    });
+  }
+}