@mastra/client-js 0.0.0-storage-20250225005900 → 0.0.0-stream-vnext-usage-20250908171242

package/src/example.ts

@@ -1,43 +0,0 @@
-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!',
-        },
-      ],
-    });
-
-    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

@@ -1,597 +0,0 @@
-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',
-    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',
-          },
-        ],
-      });
-
-      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/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),
-        }),
-      );
-    });
-  });
-
-  const agentId = 'test-agent';
-
-  describe('Memory Thread Resource', () => {
-    const threadId = 'test-thread';
-    let memoryThread: ReturnType<typeof client.getMemoryThread>;
-
-    beforeEach(() => {
-      memoryThread = client.getMemoryThread(threadId, agentId);
-    });
-
-    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 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 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 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),
-        }),
-      );
-    });
-
-    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 }),
-        },
-      );
-    });
-  });
-
-  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({ 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: '' }),
-      });
-    });
-  });
-
-  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',
-          }),
-        }),
-      );
-    });
-  });
-});

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './client';
-export * from './types';