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

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 {
@@ -13,13 +13,16 @@ import type {
 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
@@ -34,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
@@ -70,17 +75,17 @@ export class Agent {
      * @param params - Stream parameters including prompt
      * @returns Promise containing the streamed response
      */
-    stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: StreamParams<T>): Promise<StreamReturn<T>> {
+    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}/generate`, {
+        return this.request(`/api/agents/${this.agentId}/stream`, {
             method: 'POST',
             body: processedParams,
-        });
+        }) as T extends undefined ? Promise<ReadableStream<Uint8Array>> : Promise<Response>;
     }
 
     /**

package/src/resources/base.ts

@@ -0,0 +1,79 @@
+import type { RequestFunction, RequestOptions, ClientOptions } from '../types';
+
+export class BaseResource {
+    readonly options: ClientOptions
+
+    constructor(options: ClientOptions) {
+        this.options = options;
+    }
+
+    /**
+     * Makes an HTTP request to the API with retries and exponential backoff
+     * @param path - The API endpoint path
+     * @param options - Optional request configuration
+     * @returns Promise containing the response data
+     */
+    public async request<T>(path: string, options: RequestOptions = {}): Promise<T> {
+        let lastError: Error | null = null;
+        const { baseUrl, retries = 3, backoffMs = 100, maxBackoffMs = 1000, headers = {} } = this.options;
+
+
+        let delay = backoffMs;
+
+
+        for (let attempt = 0; attempt <= retries; attempt++) {
+            try {
+                const response = await fetch(`${baseUrl}${path}`, {
+                    ...options,
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...headers,
+                        ...options.headers,
+                    },
+                    body: options.body ? JSON.stringify(options.body) : undefined,
+                });
+
+                if (!response.ok) {
+                    const errorBody = await response.text();
+                    let errorMessage = `HTTP error! status: ${response.status}`;
+                    try {
+                        // Try to parse as JSON for structured error messages
+                        const errorJson = JSON.parse(errorBody);
+                        errorMessage += ` - ${JSON.stringify(errorJson)}`;
+                    } catch {
+                        // If not JSON, include the raw error body if present
+                        if (errorBody) {
+                            errorMessage += ` - ${errorBody}`;
+                        }
+                    }
+                    throw new Error(errorMessage);
+                }
+
+                // For streaming responses, return the stream directly
+                if (response.headers.get('Content-Type')?.includes('text/event-stream')) {
+                    return response.body as T;
+                }
+
+                // For unknown responses, return the response as is
+                if (response.headers.get('Content-Type')?.includes('text/x-unknown')) {
+                    return response as T;
+                }
+
+                const data = await response.json();
+                return data as T;
+            } catch (error) {
+                lastError = error as Error;
+
+                if (attempt === retries) {
+                    break;
+                }
+
+                // Wait with exponential backoff
+                await new Promise(resolve => setTimeout(resolve, delay));
+                delay = Math.min(delay * 2, maxBackoffMs);
+            }
+        }
+
+        throw lastError || new Error('Request failed');
+    }
+} 

package/src/resources/index.ts

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

package/src/resources/memory-thread.ts

@@ -1,15 +1,21 @@
-import type { StorageThreadType } from '@mastra/core/memory';
+import type { StorageThreadType } from '@mastra/core';
 import type {
+    CreateMemoryThreadParams,
     GetMemoryThreadMessagesResponse,
+    GetMemoryThreadResponse,
+    ClientOptions,
+    SaveMessageToMemoryParams,
     UpdateMemoryThreadParams,
-    RequestFunction
 } from '../types';
+import { BaseResource } from './base';
 
-export class MemoryThread {
+export class MemoryThread extends BaseResource {
     constructor(
-        private request: RequestFunction,
+        options: ClientOptions,
         private threadId: string
-    ) { }
+    ) {
+        super(options);
+    }
 
     /**
      * Retrieves the memory thread details

package/src/resources/tool.ts

@@ -1,10 +1,13 @@
-import type { GetToolResponse, RequestFunction } from '../types';
+import type { GetToolResponse, ClientOptions } from '../types';
+import { BaseResource } from './base';
 
-export class Tool {
+export class Tool extends BaseResource {
     constructor(
-        private request: RequestFunction,
+        options: ClientOptions,
         private toolId: string
-    ) { }
+    ) {
+        super(options);
+    }
 
     /**
      * Retrieves details about the tool

package/src/resources/vector.ts

@@ -3,15 +3,18 @@ import type {
     GetVectorIndexResponse,
     QueryVectorParams,
     QueryVectorResponse,
+    ClientOptions,
     UpsertVectorParams,
-    RequestFunction
 } from '../types';
+import { BaseResource } from './base';
 
-export class Vector {
+export class Vector extends BaseResource {
     constructor(
-        private request: RequestFunction,
+        options: ClientOptions,
         private vectorName: string
-    ) { }
+    ) {
+        super(options);
+    }
 
     /**
      * Retrieves details about a specific vector index

package/src/resources/workflow.ts

@@ -1,10 +1,13 @@
-import type { GetWorkflowResponse, RequestFunction } from '../types';
+import type { GetWorkflowResponse, ClientOptions } from '../types';
+import { BaseResource } from './base';
 
-export class Workflow {
+export class Workflow extends BaseResource {
     constructor(
-        private request: RequestFunction,
+        options: ClientOptions,
         private workflowId: string
-    ) { }
+    ) {
+        super(options);
+    }
 
     /**
      * Retrieves details about the workflow