@mastra/client-js 0.1.0-alpha.1 → 0.1.0-alpha.11

package/src/example.ts

@@ -0,0 +1,47 @@
+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?.body?.getReader()
+        const decoder = new TextDecoder()
+        let buffer = ''
+
+        while (true) {
+            if (!reader) break;
+            const { value, done } = await reader.read()
+            if (done) break;
+
+            const chunk = decoder.decode(value);
+            buffer += chunk;
+
+            console.log(buffer);
+
+            const matches = buffer.matchAll(/0:"([^"]*)"/g);
+
+            for (const match of matches) {
+                const content = match[1];
+                process.stdout.write(`${content}\n`);
+            }
+        }
+    } catch (error) {
+        console.error(error);
+    }
+})()

package/src/index.test.ts

@@ -0,0 +1,585 @@
+import { describe, expect, beforeEach, it, vi } from 'vitest';
+import { MastraClient } from "./client";
+import type { MessageType } from '@mastra/core';
+
+// Mock fetch globally
+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, 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(() => {
+        vi.clearAllMocks();
+        client = new MastraClient(clientOptions);
+    });
+
+    describe('Vector Resource', () => {
+        const vectorName = 'test-vector';
+        let vector: ReturnType<typeof client.getVector>;
+
+        beforeEach(() => {
+            vector = client.getVector(vectorName);
+        });
+
+        it('should get vector index details', async () => {
+            const mockResponse = {
+                dimension: 128,
+                metric: 'cosine',
+                count: 1000
+            };
+            mockFetchResponse(mockResponse);
+
+            const result = await vector.details('test-index');
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/vector/test-vector/indexes/test-index`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
+            );
+        });
+
+        it('should delete vector index', async () => {
+            mockFetchResponse({ success: true });
+            const result = await vector.delete('test-index');
+            expect(result).toEqual({ success: true });
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/vector/test-vector/indexes/test-index`,
+                expect.objectContaining({
+                    method: 'DELETE',
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
+            );
+        });
+
+        it('should get all indexes', async () => {
+            const mockResponse = { indexes: ['index1', 'index2'] };
+            mockFetchResponse(mockResponse);
+            const result = await vector.getIndexes();
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/vector/test-vector/indexes`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
+            );
+        });
+
+        it('should create vector index with all parameters', async () => {
+            mockFetchResponse({ success: true });
+            const result = await vector.createIndex({
+                indexName: 'test-index',
+                dimension: 128,
+                metric: 'cosine'
+            });
+            expect(result).toEqual({ success: true });
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${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,
+                        metric: 'cosine'
+                    })
+                })
+            );
+        });
+
+        it('should upsert vectors with metadata and ids', async () => {
+            const mockResponse = ['id1', 'id2'];
+            mockFetchResponse(mockResponse);
+            const result = await vector.upsert({
+                indexName: 'test-index',
+                vectors: [[1, 2], [3, 4]],
+                metadata: [{ label: 'a' }, { label: 'b' }],
+                ids: ['id1', 'id2']
+            });
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${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]],
+                        metadata: [{ label: 'a' }, { label: 'b' }],
+                        ids: ['id1', 'id2']
+                    })
+                })
+            );
+        });
+
+        it('should query vectors with all parameters', async () => {
+            const mockResponse = {
+                results: [{
+                    id: 'id1',
+                    score: 0.9,
+                    metadata: { label: 'a' },
+                    vector: [1, 2]
+                }]
+            };
+            mockFetchResponse(mockResponse);
+            const result = await vector.query({
+                indexName: 'test-index',
+                queryVector: [1, 2],
+                topK: 10,
+                filter: { label: 'a' },
+                includeVector: true
+            });
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${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],
+                        topK: 10,
+                        filter: { label: 'a' },
+                        includeVector: true
+                    })
+                })
+            );
+        });
+    });
+
+    describe('Agent Resource', () => {
+        const agentId = 'test-agent';
+        let agent: ReturnType<typeof client.getAgent>;
+
+        beforeEach(() => {
+            agent = client.getAgent(agentId);
+        });
+
+        it('should get all agents', async () => {
+            const mockResponse = {
+                'agent1': { name: 'Agent 1', model: 'gpt-4' },
+                'agent2': { name: 'Agent 2', model: 'gpt-3.5' }
+            };
+            mockFetchResponse(mockResponse);
+            const result = await client.getAgents();
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/agents`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
+            );
+        });
+
+        it('should get agent details', async () => {
+            const mockResponse = {
+                name: 'Test Agent',
+                model: 'gpt-4',
+                instructions: 'Test instructions',
+                tools: {}
+            };
+            mockFetchResponse(mockResponse);
+
+            const result = await agent.details();
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/agents/test-agent`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
+            );
+        });
+
+        it('should generate response', async () => {
+            const mockResponse = {
+                response: 'Generated response'
+            };
+            mockFetchResponse(mockResponse);
+
+            const result = await agent.generate({
+                messages: [],
+                threadId: 'test-thread',
+                resourceid: 'test-resource',
+                output: {}
+            });
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/agents/test-agent/generate`,
+                expect.objectContaining({
+                    method: 'POST',
+                    headers: expect.objectContaining(clientOptions.headers),
+                    body: JSON.stringify({
+                        messages: [],
+                        threadId: 'test-thread',
+                        resourceid: 'test-resource',
+                        output: {}
+                    })
+                })
+            );
+        });
+
+        it('should stream responses', async () => {
+            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(response.body).toBeInstanceOf(ReadableStream);
+            const reader = response?.body?.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 () => {
+            const mockResponse = {
+                id: 'tool1',
+                description: 'Test Tool'
+            };
+            mockFetchResponse(mockResponse);
+            const result = await agent.getTool('tool1');
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/agents/test-agent/tools/tool1`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
+            );
+        });
+
+        it('should get agent evals', async () => {
+            const mockResponse = {
+                name: 'Test Agent',
+                evals: [{ id: 'eval1' }]
+            };
+            mockFetchResponse(mockResponse);
+            const result = await agent.evals();
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/agents/test-agent/evals`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
+            );
+        });
+
+        it('should get live evals', async () => {
+            const mockResponse = {
+                name: 'Test Agent',
+                evals: [{ id: 'eval1', live: true }]
+            };
+            mockFetchResponse(mockResponse);
+            const result = await agent.liveEvals();
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/agents/test-agent/evals/live`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
+            );
+        });
+    });
+
+    describe('Memory Thread Resource', () => {
+        const threadId = 'test-thread';
+        let memoryThread: ReturnType<typeof client.getMemoryThread>;
+
+        beforeEach(() => {
+            memoryThread = client.getMemoryThread(threadId);
+        });
+
+        it('should get thread details', async () => {
+            const mockResponse = {
+                id: threadId,
+                title: 'Test Thread',
+                metadata: {}
+            };
+            mockFetchResponse(mockResponse);
+
+            const result = await memoryThread.get();
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/memory/threads/test-thread`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
+            );
+        });
+
+        it('should update thread', async () => {
+            const mockResponse = {
+                id: threadId,
+                title: 'Updated Thread',
+                metadata: { updated: true }
+            };
+            mockFetchResponse(mockResponse);
+
+            const result = await memoryThread.update({
+                title: 'Updated Thread',
+                metadata: { updated: true },
+                resourceid: 'test-resource'
+            });
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/memory/threads/test-thread`,
+                expect.objectContaining({
+                    method: 'PATCH',
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
+            );
+        });
+
+        it('should delete thread', async () => {
+            const mockResponse = { result: 'deleted' };
+            mockFetchResponse(mockResponse);
+            const result = await memoryThread.delete();
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/memory/threads/test-thread`,
+                expect.objectContaining({
+                    method: 'DELETE',
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
+            );
+        });
+
+        it('should get memory status', async () => {
+            const mockResponse = { result: true };
+            mockFetchResponse(mockResponse);
+            const result = await client.getMemoryStatus();
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/memory/status`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
+            );
+        });
+
+        it('should save messages to memory', async () => {
+            const messages: MessageType[] = [{
+                id: '1',
+                type: 'text',
+                content: 'test',
+                role: 'user',
+                threadId: 'test-thread',
+                createdAt: new Date()
+            }];
+            mockFetchResponse(messages);
+            const result = await client.saveMessageToMemory({ messages });
+            expect(result).toEqual(messages);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/memory/save-messages`,
+                expect.objectContaining({
+                    method: 'POST',
+                    headers: expect.objectContaining(clientOptions.headers),
+                    body: JSON.stringify({ messages })
+                })
+            );
+        });
+    });
+
+    describe('Tool Resource', () => {
+        const toolId = 'test-tool';
+        let tool: ReturnType<typeof client.getTool>;
+
+        beforeEach(() => {
+            tool = client.getTool(toolId);
+        });
+
+        it('should get tool details', async () => {
+            const mockResponse = {
+                id: toolId,
+                description: 'Test Tool',
+                inputSchema: '{}',
+                outputSchema: '{}'
+            };
+            mockFetchResponse(mockResponse);
+
+            const result = await tool.details();
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/tools/test-tool`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
+            );
+        });
+
+        it('should execute tool', async () => {
+            const mockResponse = {
+                result: 'Tool execution result'
+            };
+            mockFetchResponse(mockResponse);
+
+            const result = await tool.execute({ input: 'test' });
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/tools/test-tool/execute`,
+                expect.objectContaining({
+                    method: 'POST',
+                    headers: expect.objectContaining(clientOptions.headers),
+                    body: JSON.stringify({ input: 'test' })
+                })
+            );
+        });
+    });
+
+    describe('Workflow Resource', () => {
+        const workflowId = 'test-workflow';
+        let workflow: ReturnType<typeof client.getWorkflow>;
+
+        beforeEach(() => {
+            workflow = client.getWorkflow(workflowId);
+        });
+
+        it('should get workflow details', async () => {
+            const mockResponse = {
+                name: 'Test Workflow',
+                triggerSchema: '{}',
+                steps: {},
+                stepGraph: {},
+                stepSubscriberGraph: {}
+            };
+            mockFetchResponse(mockResponse);
+
+            const result = await workflow.details();
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/workflows/test-workflow`,
+                expect.objectContaining({
+                    headers: expect.objectContaining(clientOptions.headers)
+                })
+            );
+        });
+
+        it('should execute workflow', async () => {
+            const mockResponse = {
+                result: 'Workflow execution result'
+            };
+            mockFetchResponse(mockResponse);
+
+            const result = await workflow.execute({ trigger: 'test' });
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith(
+                `${clientOptions.baseUrl}/api/workflows/test-workflow/execute`,
+                expect.objectContaining({
+                    method: 'POST',
+                    headers: expect.objectContaining(clientOptions.headers),
+                    body: JSON.stringify({ trigger: 'test' })
+                })
+            );
+        });
+    });
+
+    describe('Client Error Handling', () => {
+        it('should retry failed requests', async () => {
+            // Mock first two calls to fail, third to succeed
+            (global.fetch as any)
+                .mockRejectedValueOnce(new Error('Network error'))
+                .mockRejectedValueOnce(new Error('Network error'))
+                .mockResolvedValueOnce({
+                    ok: true,
+                    headers: {
+                        get: () => 'application/json'
+                    },
+                    json: async () => ({ success: true })
+                });
+
+            const result = await client.request('/test-endpoint');
+            expect(result).toEqual({ success: true });
+            expect(global.fetch).toHaveBeenCalledTimes(3);
+        });
+
+        it('should throw error after max retries', async () => {
+            (global.fetch as any).mockRejectedValue(new Error('Network error'));
+
+            await expect(client.request('/test-endpoint'))
+                .rejects
+                .toThrow('Network error');
+
+            expect(global.fetch).toHaveBeenCalledTimes(4);
+        });
+    });
+
+    describe('Client Configuration', () => {
+        it('should handle custom retry configuration', async () => {
+            const customClient = new MastraClient({
+                baseUrl: 'http://localhost:4111',
+                retries: 2,
+                backoffMs: 100,
+                maxBackoffMs: 1000,
+                headers: { 'Custom-Header': 'value' }
+            });
+
+            (global.fetch as any)
+                .mockRejectedValueOnce(new Error('Network error'))
+                .mockRejectedValueOnce(new Error('Network error'))
+                .mockResolvedValueOnce({
+                    ok: true,
+                    headers: {
+                        get: () => 'application/json'
+                    },
+                    json: async () => ({ success: true })
+                });
+
+            const result = await customClient.request('/test');
+            expect(result).toEqual({ success: true });
+            expect(global.fetch).toHaveBeenCalledTimes(3);
+            expect(global.fetch).toHaveBeenCalledWith(
+                'http://localhost:4111/test',
+                expect.objectContaining({
+                    headers: expect.objectContaining({
+                        'Custom-Header': 'value'
+                    })
+                })
+            );
+        });
+    });
+});