@mastra/client-js 0.1.0-alpha.9 → 0.1.1

package/src/index.test.ts

@@ -1,585 +1,597 @@
-import { describe, expect, beforeEach, it, vi } from 'vitest';
-import { MastraClient } from "./client";
 import type { MessageType } from '@mastra/core';
+import { describe, expect, beforeEach, it, vi } from 'vitest';
+
+import { MastraClient } from './client';
 
 // Mock fetch globally
 global.fetch = vi.fn();
 
 describe('MastraClient Resources', () => {
-    let client: MastraClient;
-    const clientOptions = {
-        baseUrl: 'http://localhost:4111',
+  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: {
-            '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
-            });
-        }
-    };
+          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(() => {
-        vi.clearAllMocks();
-        client = new MastraClient(clientOptions);
+      vector = client.getVector(vectorName);
     });
 
-    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 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 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 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 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 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
-                    })
-                })
-            );
-        });
+    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>;
+  describe('Agent Resource', () => {
+    const agentId = 'test-agent';
+    let agent: ReturnType<typeof client.getAgent>;
 
-        beforeEach(() => {
-            agent = client.getAgent(agentId);
-        });
+    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 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 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 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 stream responses', async () => {
+      const mockChunk = { content: 'test response' };
+      mockFetchResponse(mockChunk, { isStream: true });
+
+      const response = await agent.stream({
+        messages: [
+          {
+            role: 'user',
+            content: 'test',
+          },
+        ],
+      });
+
+      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 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 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/ci`, {
+        headers: {
+          Authorization: 'Bearer test-key',
+          'Content-Type': 'application/json',
+        },
+      });
+    });
 
-        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)
-                })
-            );
-        });
+    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>;
+  const agentId = 'test-agent';
 
-        beforeEach(() => {
-            memoryThread = client.getMemoryThread(threadId);
-        });
+  describe('Memory Thread Resource', () => {
+    const threadId = 'test-thread';
+    let memoryThread: ReturnType<typeof client.getMemoryThread>;
 
-        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)
-                })
-            );
-        });
+    beforeEach(() => {
+      memoryThread = client.getMemoryThread(threadId, agentId);
+    });
 
-        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 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?agentId=${agentId}`,
+        expect.objectContaining({
+          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 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?agentId=${agentId}`,
+        expect.objectContaining({
+          method: 'PATCH',
+          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 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?agentId=${agentId}`,
+        expect.objectContaining({
+          method: 'DELETE',
+          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 })
-                })
-            );
-        });
+    it('should get memory status', async () => {
+      const mockResponse = { result: true };
+      mockFetchResponse(mockResponse);
+      const result = await client.getMemoryStatus(agentId);
+      expect(result).toEqual(mockResponse);
+      expect(global.fetch).toHaveBeenCalledWith(
+        `${clientOptions.baseUrl}/api/memory/status?agentId=${agentId}`,
+        expect.objectContaining({
+          headers: expect.objectContaining(clientOptions.headers),
+        }),
+      );
     });
 
-    describe('Tool Resource', () => {
-        const toolId = 'test-tool';
-        let tool: ReturnType<typeof client.getTool>;
+    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, agentId });
+      expect(result).toEqual(messages);
+      expect(global.fetch).toHaveBeenCalledWith(
+        `${clientOptions.baseUrl}/api/memory/save-messages?agentId=${agentId}`,
+        {
+          method: 'POST',
+          headers: {
+            Authorization: 'Bearer test-key',
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ messages, agentId }),
+        },
+      );
+    });
+  });
 
-        beforeEach(() => {
-            tool = client.getTool(toolId);
-        });
+  describe('Tool Resource', () => {
+    const toolId = 'test-tool';
+    let tool: ReturnType<typeof client.getTool>;
 
-        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)
-                })
-            );
-        });
+    beforeEach(() => {
+      tool = client.getTool(toolId);
+    });
 
-        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' })
-                })
-            );
-        });
+    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),
+        }),
+      );
     });
 
-    describe('Workflow Resource', () => {
-        const workflowId = 'test-workflow';
-        let workflow: ReturnType<typeof client.getWorkflow>;
+    it('should execute tool', async () => {
+      const mockResponse = {
+        result: 'Tool execution result',
+      };
+      mockFetchResponse(mockResponse);
 
-        beforeEach(() => {
-            workflow = client.getWorkflow(workflowId);
-        });
+      const result = await tool.execute({ data: '' });
+      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: '' }),
+      });
+    });
+  });
 
-        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)
-                })
-            );
-        });
+  describe('Workflow Resource', () => {
+    const workflowId = 'test-workflow';
+    let workflow: ReturnType<typeof client.getWorkflow>;
 
-        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' })
-                })
-            );
-        });
+    beforeEach(() => {
+      workflow = client.getWorkflow(workflowId);
     });
 
-    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 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 }),
         });
 
-        it('should throw error after max retries', async () => {
-            (global.fetch as any).mockRejectedValue(new Error('Network error'));
+      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');
+      await expect(client.request('/test-endpoint')).rejects.toThrow('Network error');
 
-            expect(global.fetch).toHaveBeenCalledTimes(4);
-        });
+      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'
-                    })
-                })
-            );
+  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',
+          }),
+        }),
+      );
     });
+  });
 });