@mastra/client-js 0.1.0-alpha.5 → 0.1.0-alpha.7

package/src/client.ts

@@ -1,63 +1,12 @@
 import type { ClientOptions, CreateMemoryThreadParams, CreateMemoryThreadResponse, GetAgentResponse, GetLogParams, GetLogsParams, GetLogsResponse, GetMemoryThreadParams, GetMemoryThreadResponse, GetToolResponse, GetWorkflowResponse, RequestOptions, SaveMessageToMemoryParams, SaveMessageToMemoryResponse } from './types';
-import { Agent, MemoryThread, Tool, Workflow, Vector } from './resources';
+import { Agent, MemoryThread, Tool, Workflow, Vector, BaseResource } from './resources';
 
-export class MastraClient {
-    readonly baseUrl: string;
-    private readonly retries: number;
-    private readonly backoffMs: number;
-    private readonly maxBackoffMs: number;
-    private readonly headers: Record<string, string>;
+export class MastraClient extends BaseResource {
 
     constructor(options: ClientOptions) {
-        this.baseUrl = options.baseUrl.replace(/\/$/, '');
-        this.retries = options.retries ?? 3;
-        this.backoffMs = options.backoffMs ?? 300;
-        this.maxBackoffMs = options.maxBackoffMs ?? 5000;
-        this.headers = {
-            'Content-Type': 'application/json',
-            ...options.headers,
-        };
+        super(options);
     }
 
-    /**
-     * Makes an HTTP request to the Mastra API
-     * @param path - API endpoint path
-     * @param options - Request options including method, headers, and body
-     * @returns Promise containing the API response
-     * @throws Error if the request fails after all retries
-     */
-    async request(path: string, options: RequestOptions = {}): Promise<any> {
-        const url = `${this.baseUrl}${path}`;
-        let lastError: Error | null = null;
-        let currentBackoff = this.backoffMs;
-
-        for (let attempt = 0; attempt <= this.retries; attempt++) {
-            try {
-                const response = await fetch(url, {
-                    method: options.method ?? 'GET',
-                    headers: {
-                        ...this.headers,
-                        ...options.headers,
-                    },
-                    body: options.body ? JSON.stringify(options.body) : undefined,
-                });
-
-                if (!response.ok) {
-                    throw new Error(`HTTP error! status: ${response.status}`);
-                }
-
-                return await response.json();
-            } catch (error) {
-                lastError = error as Error;
-                if (attempt === this.retries) break;
-
-                await new Promise(resolve => setTimeout(resolve, currentBackoff));
-                currentBackoff = Math.min(currentBackoff * 2, this.maxBackoffMs);
-            }
-        }
-
-        throw lastError;
-    }
 
     /**
      * Retrieves all available agents
@@ -73,10 +22,7 @@ export class MastraClient {
      * @returns Agent instance
      */
     public getAgent(agentId: string) {
-        return new Agent(
-            (path: string, options?: RequestOptions) => this.request(path, options),
-            agentId
-        );
+        return new Agent(this.options, agentId);
     }
 
     /**
@@ -103,10 +49,7 @@ export class MastraClient {
      * @returns MemoryThread instance
      */
     public getMemoryThread(threadId: string) {
-        return new MemoryThread(
-            (path: string, options?: RequestOptions) => this.request(path, options),
-            threadId
-        );
+        return new MemoryThread(this.options, threadId);
     }
 
     /**
@@ -143,10 +86,7 @@ export class MastraClient {
      * @returns Tool instance
      */
     public getTool(toolId: string) {
-        return new Tool(
-            (path: string, options?: RequestOptions) => this.request(path, options),
-            toolId
-        );
+        return new Tool(this.options, toolId);
     }
 
     /**
@@ -163,10 +103,7 @@ export class MastraClient {
      * @returns Workflow instance
      */
     public getWorkflow(workflowId: string) {
-        return new Workflow(
-            (path: string, options?: RequestOptions) => this.request(path, options),
-            workflowId
-        );
+        return new Workflow(this.options, workflowId);
     }
 
     /**
@@ -175,10 +112,7 @@ export class MastraClient {
      * @returns Vector instance
      */
     public getVector(vectorName: string) {
-        return new Vector(
-            (path: string, options?: RequestOptions) => this.request(path, options),
-            vectorName
-        );
+        return new Vector(this.options, vectorName);
     }
 
     /**

package/src/example.ts

@@ -0,0 +1,34 @@
+import { MastraClient } from "./client";
+
+
+(async () => {
+    const client = new MastraClient({
+        baseUrl: 'http://localhost:4111',
+    });
+
+    try {
+        const agent = client.getAgent('weatherAgent');
+        const response = await agent.stream({
+            messages: [{
+                role: 'user',
+                content: 'Hello, world!',
+                id: '1',
+                createdAt: new Date(),
+                threadId: '1',
+                type: 'text',
+            }],
+        })
+
+
+        const reader = response?.getReader()
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            const text = new TextDecoder().decode(value);
+            console.log(text);
+        }
+    } catch (error) {
+        console.error(error);
+    }
+})()

package/src/index.test.ts

@@ -7,26 +7,43 @@ global.fetch = vi.fn();
 
 describe('MastraClient Resources', () => {
     let client: MastraClient;
+    const clientOptions = {
+        baseUrl: 'http://localhost:4111',
+        headers: {
+            'Authorization': 'Bearer test-key'
+        }
+    };
 
     // Helper to mock successful API responses
-    const mockFetchResponse = (data: any) => {
-        (global.fetch as any).mockResolvedValueOnce({
-            ok: true,
-            json: async () => data
-        });
+    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
+            });
+        } else {
+            (global.fetch as any).mockResolvedValueOnce({
+                ok: true,
+                headers: {
+                    get: (name: string) => name === 'Content-Type' ? 'application/json' : null
+                },
+                json: async () => data
+            });
+        }
     };
 
     beforeEach(() => {
-        // Reset mocks
         vi.clearAllMocks();
-
-        // Create fresh client for each test
-        client = new MastraClient({
-            baseUrl: 'http://localhost:4111',
-            headers: {
-                'Authorization': 'Bearer test-key'
-            }
-        });
+        client = new MastraClient(clientOptions);
     });
 
     describe('Vector Resource', () => {
@@ -48,8 +65,10 @@ describe('MastraClient Resources', () => {
             const result = await vector.details('test-index');
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/vector/test-vector/indexes/test-index`,
-                expect.any(Object)
+                `${clientOptions.baseUrl}/api/vector/test-vector/indexes/test-index`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
             );
         });
 
@@ -58,8 +77,11 @@ describe('MastraClient Resources', () => {
             const result = await vector.delete('test-index');
             expect(result).toEqual({ success: true });
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/vector/test-vector/indexes/test-index`,
-                expect.objectContaining({ method: 'DELETE' })
+                `${clientOptions.baseUrl}/api/vector/test-vector/indexes/test-index`,
+                expect.objectContaining({
+                    method: 'DELETE',
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
             );
         });
 
@@ -69,8 +91,10 @@ describe('MastraClient Resources', () => {
             const result = await vector.getIndexes();
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/vector/test-vector/indexes`,
-                expect.any(Object)
+                `${clientOptions.baseUrl}/api/vector/test-vector/indexes`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
             );
         });
 
@@ -83,9 +107,10 @@ describe('MastraClient Resources', () => {
             });
             expect(result).toEqual({ success: true });
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/vector/test-vector/create-index`,
+                `${clientOptions.baseUrl}/api/vector/test-vector/create-index`,
                 expect.objectContaining({
                     method: 'POST',
+                    headers: expect.objectContaining(clientOptions.headers),
                     body: JSON.stringify({
                         indexName: 'test-index',
                         dimension: 128,
@@ -106,9 +131,10 @@ describe('MastraClient Resources', () => {
             });
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/vector/test-vector/upsert`,
+                `${clientOptions.baseUrl}/api/vector/test-vector/upsert`,
                 expect.objectContaining({
                     method: 'POST',
+                    headers: expect.objectContaining(clientOptions.headers),
                     body: JSON.stringify({
                         indexName: 'test-index',
                         vectors: [[1, 2], [3, 4]],
@@ -138,9 +164,10 @@ describe('MastraClient Resources', () => {
             });
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/vector/test-vector/query`,
+                `${clientOptions.baseUrl}/api/vector/test-vector/query`,
                 expect.objectContaining({
                     method: 'POST',
+                    headers: expect.objectContaining(clientOptions.headers),
                     body: JSON.stringify({
                         indexName: 'test-index',
                         queryVector: [1, 2],
@@ -170,8 +197,10 @@ describe('MastraClient Resources', () => {
             const result = await client.getAgents();
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/agents`,
-                expect.any(Object)
+                `${clientOptions.baseUrl}/api/agents`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
             );
         });
 
@@ -187,8 +216,10 @@ describe('MastraClient Resources', () => {
             const result = await agent.details();
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/agents/test-agent`,
-                expect.any(Object)
+                `${clientOptions.baseUrl}/api/agents/test-agent`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
             );
         });
 
@@ -206,9 +237,10 @@ describe('MastraClient Resources', () => {
             });
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/agents/test-agent/generate`,
+                `${clientOptions.baseUrl}/api/agents/test-agent/generate`,
                 expect.objectContaining({
                     method: 'POST',
+                    headers: expect.objectContaining(clientOptions.headers),
                     body: JSON.stringify({
                         messages: [],
                         threadId: 'test-thread',
@@ -220,31 +252,29 @@ describe('MastraClient Resources', () => {
         });
 
         it('should stream responses', async () => {
-            const mockResponse = {
-                stream: true,
-                chunks: ['chunk1', 'chunk2']
-            };
-            mockFetchResponse(mockResponse);
-            const result = await agent.stream({
-                messages: [],
-                threadId: 'test-thread',
-                resourceid: 'test-resource',
-                output: undefined
+            const mockChunk = { content: 'test response' };
+            mockFetchResponse(mockChunk, { isStream: true });
+
+            const response = await agent.stream({
+                messages: [{
+                    role: 'user',
+                    content: 'test',
+                    id: '1',
+                    createdAt: new Date(),
+                    threadId: '1',
+                    type: 'text'
+                }]
             });
-            expect(result).toEqual(mockResponse);
-            expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/agents/test-agent/generate`,
-                expect.objectContaining({
-                    method: 'POST',
-                    body: JSON.stringify({
-                        messages: [],
-                        threadId: 'test-thread',
-                        resourceid: 'test-resource',
-                        output: undefined,
-                        stream: true
-                    })
-                })
-            );
+
+            expect(response).toBeInstanceOf(ReadableStream);
+            const reader = response?.getReader();
+            expect(reader).toBeDefined();
+
+            if (reader) {
+                const { value, done } = await reader.read();
+                expect(done).toBe(false);
+                expect(new TextDecoder().decode(value)).toBe(JSON.stringify(mockChunk));
+            }
         });
 
         it('should get agent tool', async () => {
@@ -256,8 +286,10 @@ describe('MastraClient Resources', () => {
             const result = await agent.getTool('tool1');
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/agents/test-agent/tools/tool1`,
-                expect.any(Object)
+                `${clientOptions.baseUrl}/api/agents/test-agent/tools/tool1`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
             );
         });
 
@@ -270,8 +302,10 @@ describe('MastraClient Resources', () => {
             const result = await agent.evals();
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/agents/test-agent/evals`,
-                expect.any(Object)
+                `${clientOptions.baseUrl}/api/agents/test-agent/evals`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
             );
         });
 
@@ -284,8 +318,10 @@ describe('MastraClient Resources', () => {
             const result = await agent.liveEvals();
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/agents/test-agent/evals/live`,
-                expect.any(Object)
+                `${clientOptions.baseUrl}/api/agents/test-agent/evals/live`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
             );
         });
     });
@@ -309,8 +345,10 @@ describe('MastraClient Resources', () => {
             const result = await memoryThread.get();
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/memory/threads/test-thread`,
-                expect.any(Object)
+                `${clientOptions.baseUrl}/api/memory/threads/test-thread`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
             );
         });
 
@@ -329,9 +367,10 @@ describe('MastraClient Resources', () => {
             });
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/memory/threads/test-thread`,
+                `${clientOptions.baseUrl}/api/memory/threads/test-thread`,
                 expect.objectContaining({
-                    method: 'PATCH'
+                    method: 'PATCH',
+                    headers: expect.objectContaining(clientOptions.headers)
                 })
             );
         });
@@ -342,8 +381,11 @@ describe('MastraClient Resources', () => {
             const result = await memoryThread.delete();
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/memory/threads/test-thread`,
-                expect.objectContaining({ method: 'DELETE' })
+                `${clientOptions.baseUrl}/api/memory/threads/test-thread`,
+                expect.objectContaining({
+                    method: 'DELETE',
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
             );
         });
 
@@ -353,8 +395,10 @@ describe('MastraClient Resources', () => {
             const result = await client.getMemoryStatus();
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/memory/status`,
-                expect.any(Object)
+                `${clientOptions.baseUrl}/api/memory/status`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
             );
         });
 
@@ -371,9 +415,10 @@ describe('MastraClient Resources', () => {
             const result = await client.saveMessageToMemory({ messages });
             expect(result).toEqual(messages);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/memory/save-messages`,
+                `${clientOptions.baseUrl}/api/memory/save-messages`,
                 expect.objectContaining({
                     method: 'POST',
+                    headers: expect.objectContaining(clientOptions.headers),
                     body: JSON.stringify({ messages })
                 })
             );
@@ -400,8 +445,10 @@ describe('MastraClient Resources', () => {
             const result = await tool.details();
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/tools/test-tool`,
-                expect.any(Object)
+                `${clientOptions.baseUrl}/api/tools/test-tool`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
             );
         });
 
@@ -414,9 +461,10 @@ describe('MastraClient Resources', () => {
             const result = await tool.execute({ input: 'test' });
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/tools/test-tool/execute`,
+                `${clientOptions.baseUrl}/api/tools/test-tool/execute`,
                 expect.objectContaining({
                     method: 'POST',
+                    headers: expect.objectContaining(clientOptions.headers),
                     body: JSON.stringify({ input: 'test' })
                 })
             );
@@ -444,8 +492,10 @@ describe('MastraClient Resources', () => {
             const result = await workflow.details();
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/workflows/test-workflow`,
-                expect.any(Object)
+                `${clientOptions.baseUrl}/api/workflows/test-workflow`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
             );
         });
 
@@ -458,9 +508,10 @@ describe('MastraClient Resources', () => {
             const result = await workflow.execute({ trigger: 'test' });
             expect(result).toEqual(mockResponse);
             expect(global.fetch).toHaveBeenCalledWith(
-                `${client.baseUrl}/api/workflows/test-workflow/execute`,
+                `${clientOptions.baseUrl}/api/workflows/test-workflow/execute`,
                 expect.objectContaining({
                     method: 'POST',
+                    headers: expect.objectContaining(clientOptions.headers),
                     body: JSON.stringify({ trigger: 'test' })
                 })
             );
@@ -475,6 +526,9 @@ describe('MastraClient Resources', () => {
                 .mockRejectedValueOnce(new Error('Network error'))
                 .mockResolvedValueOnce({
                     ok: true,
+                    headers: {
+                        get: () => 'application/json'
+                    },
                     json: async () => ({ success: true })
                 });
 
@@ -509,6 +563,9 @@ describe('MastraClient Resources', () => {
                 .mockRejectedValueOnce(new Error('Network error'))
                 .mockResolvedValueOnce({
                     ok: true,
+                    headers: {
+                        get: () => 'application/json'
+                    },
                     json: async () => ({ success: true })
                 });
 

package/src/resources/agent.ts

@@ -3,7 +3,7 @@ import type {
     GetAgentResponse,
     GetEvalsByAgentIdResponse,
     GetToolResponse,
-    RequestFunction,
+    ClientOptions,
     StreamParams,
 } from '../types';
 import type {
@@ -11,13 +11,18 @@ import type {
     StreamReturn,
 } from '@mastra/core';
 import type { JSONSchema7 } from 'json-schema';
+import { ZodSchema } from "zod";
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { BaseResource } from './base';
 
-export class AgentTool {
+export class AgentTool extends BaseResource {
     constructor(
-        private request: RequestFunction,
+        options: ClientOptions,
         private agentId: string,
         private toolId: string
-    ) { }
+    ) {
+        super(options);
+    }
 
     /**
      * Executes a specific tool for an agent
@@ -32,11 +37,13 @@ export class AgentTool {
     }
 }
 
-export class Agent {
+export class Agent extends BaseResource {
     constructor(
-        private request: RequestFunction,
+        options: ClientOptions,
         private agentId: string
-    ) { }
+    ) {
+        super(options);
+    }
 
     /**
      * Retrieves details about the agent
@@ -51,10 +58,15 @@ export class Agent {
      * @param params - Generation parameters including prompt
      * @returns Promise containing the generated response
      */
-    generate<T extends JSONSchema7 | undefined = undefined>(params: GenerateParams<T>): Promise<GenerateReturn<T>> {
+    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
+        };
+
         return this.request(`/api/agents/${this.agentId}/generate`, {
             method: 'POST',
-            body: params,
+            body: processedParams,
         });
     }
 
@@ -63,11 +75,17 @@ export class Agent {
      * @param params - Stream parameters including prompt
      * @returns Promise containing the streamed response
      */
-    stream<T extends JSONSchema7 | undefined = undefined>(params: StreamParams<T>): Promise<StreamReturn<T>> {
-        return this.request(`/api/agents/${this.agentId}/generate`, {
+    stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: StreamParams<T>) {
+        const processedParams = {
+            ...params,
+            output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
+            stream: true
+        };
+
+        return this.request(`/api/agents/${this.agentId}/stream`, {
             method: 'POST',
-            body: { ...params, stream: true },
-        });
+            body: processedParams,
+        }) as T extends undefined ? Promise<ReadableStream<Uint8Array>> : Promise<Response>;
     }
 
     /**