@mastra/client-js 0.11.3-alpha.3 → 0.11.3-alpha.4

package/src/utils/process-mastra-stream.test.ts

@@ -1,353 +0,0 @@
-import { ReadableStream } from 'stream/web';
-import type { ChunkType } from '@mastra/core/stream';
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import { processMastraStream } from './process-mastra-stream';
-
-describe('processMastraStream', () => {
-  let mockOnChunk: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    mockOnChunk = vi.fn().mockResolvedValue(undefined);
-    vi.clearAllMocks();
-  });
-
-  const createMockStream = (data: string): ReadableStream<Uint8Array> => {
-    return new ReadableStream({
-      start(controller) {
-        const encoder = new TextEncoder();
-        controller.enqueue(encoder.encode(data));
-        controller.close();
-      },
-    });
-  };
-
-  const createChunkedMockStream = (chunks: string[]): ReadableStream<Uint8Array> => {
-    let currentIndex = 0;
-    return new ReadableStream({
-      start(controller) {
-        const encoder = new TextEncoder();
-
-        const pushNext = () => {
-          if (currentIndex < chunks.length) {
-            controller.enqueue(encoder.encode(chunks[currentIndex]));
-            currentIndex++;
-            // Simulate async processing
-            setTimeout(pushNext, 10);
-          } else {
-            controller.close();
-          }
-        };
-
-        pushNext();
-      },
-    });
-  };
-
-  it('should process valid SSE messages and call onChunk', async () => {
-    const testChunk: ChunkType = {
-      type: 'test',
-      runId: 'run-123',
-      from: 'agent',
-      payload: { message: 'hello' },
-    };
-
-    const sseData = `data: ${JSON.stringify(testChunk)}\n\n`;
-    const stream = createMockStream(sseData);
-
-    await processMastraStream({
-      stream,
-      onChunk: mockOnChunk,
-    });
-
-    expect(mockOnChunk).toHaveBeenCalledTimes(1);
-    expect(mockOnChunk).toHaveBeenCalledWith(testChunk);
-  });
-
-  it('should process multiple SSE messages in sequence', async () => {
-    const testChunk1: ChunkType = {
-      type: 'message',
-      runId: 'run-123',
-      from: 'agent',
-      payload: { text: 'first message' },
-    };
-
-    const testChunk2: ChunkType = {
-      type: 'message',
-      runId: 'run-123',
-      from: 'agent',
-      payload: { text: 'second message' },
-    };
-
-    const sseData = `data: ${JSON.stringify(testChunk1)}\n\ndata: ${JSON.stringify(testChunk2)}\n\n`;
-    const stream = createMockStream(sseData);
-
-    await processMastraStream({
-      stream,
-      onChunk: mockOnChunk,
-    });
-
-    expect(mockOnChunk).toHaveBeenCalledTimes(2);
-    expect(mockOnChunk).toHaveBeenNthCalledWith(1, testChunk1);
-    expect(mockOnChunk).toHaveBeenNthCalledWith(2, testChunk2);
-  });
-
-  it('should handle [DONE] marker and terminate stream processing', async () => {
-    const testChunk: ChunkType = {
-      type: 'message',
-      runId: 'run-123',
-      from: 'agent',
-      payload: { text: 'message before done' },
-    };
-
-    const sseData = `data: ${JSON.stringify(testChunk)}\n\ndata: [DONE]\n\n`;
-    const stream = createMockStream(sseData);
-
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-    await processMastraStream({
-      stream,
-      onChunk: mockOnChunk,
-    });
-
-    expect(mockOnChunk).toHaveBeenCalledTimes(1);
-    expect(mockOnChunk).toHaveBeenCalledWith(testChunk);
-    expect(consoleSpy).toHaveBeenCalledWith('🏁 Stream finished');
-
-    consoleSpy.mockRestore();
-  });
-
-  it('should handle JSON parsing errors gracefully', async () => {
-    const invalidJson = 'data: {invalid json}\n\n';
-    const validChunk: ChunkType = {
-      type: 'message',
-      runId: 'run-123',
-      from: 'agent',
-      payload: { text: 'valid message' },
-    };
-    const validData = `data: ${JSON.stringify(validChunk)}\n\n`;
-
-    const sseData = invalidJson + validData;
-    const stream = createMockStream(sseData);
-
-    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    await processMastraStream({
-      stream,
-      onChunk: mockOnChunk,
-    });
-
-    // Should have called onChunk only for the valid message
-    expect(mockOnChunk).toHaveBeenCalledTimes(1);
-    expect(mockOnChunk).toHaveBeenCalledWith(validChunk);
-
-    // Should have logged the JSON parsing error
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      '❌ JSON parse error:',
-      expect.any(SyntaxError),
-      'Data:',
-      '{invalid json}',
-    );
-
-    consoleErrorSpy.mockRestore();
-  });
-
-  it('should handle incomplete SSE messages across chunks', async () => {
-    const testChunk: ChunkType = {
-      type: 'message',
-      runId: 'run-123',
-      from: 'agent',
-      payload: { text: 'complete message' },
-    };
-
-    // Split the SSE message across multiple chunks
-    const chunks = [
-      'data: {"type":"message","runId":"run-123"',
-      ',"from":"agent","payload":{"text":"complete message"}}\n\n',
-    ];
-
-    const stream = createChunkedMockStream(chunks);
-
-    await processMastraStream({
-      stream,
-      onChunk: mockOnChunk,
-    });
-
-    expect(mockOnChunk).toHaveBeenCalledTimes(1);
-    expect(mockOnChunk).toHaveBeenCalledWith(testChunk);
-  });
-
-  it('should handle empty stream', async () => {
-    const stream = createMockStream('');
-
-    await processMastraStream({
-      stream,
-      onChunk: mockOnChunk,
-    });
-
-    expect(mockOnChunk).not.toHaveBeenCalled();
-  });
-
-  it('should ignore non-data lines', async () => {
-    const testChunk: ChunkType = {
-      type: 'message',
-      runId: 'run-123',
-      from: 'agent',
-      payload: { text: 'valid message' },
-    };
-
-    // SSE format: each line ends with \n, and messages are separated by \n\n
-    const sseData = `event: test-event\nid: 123\n\ndata: ${JSON.stringify(testChunk)}\n\nretry: 5000\n\n`;
-
-    const stream = createMockStream(sseData);
-
-    await processMastraStream({
-      stream,
-      onChunk: mockOnChunk,
-    });
-
-    expect(mockOnChunk).toHaveBeenCalledTimes(1);
-    expect(mockOnChunk).toHaveBeenCalledWith(testChunk);
-  });
-
-  it('should properly clean up stream reader resources', async () => {
-    const testChunk: ChunkType = {
-      type: 'message',
-      runId: 'run-123',
-      from: 'agent',
-      payload: { text: 'test message' },
-    };
-
-    const sseData = `data: ${JSON.stringify(testChunk)}\n\n`;
-    const stream = createMockStream(sseData);
-
-    // Spy on the reader's releaseLock method
-    const reader = stream.getReader();
-    const releaseLockSpy = vi.spyOn(reader, 'releaseLock');
-    reader.releaseLock(); // Release it so processMastraStream can get it
-
-    await processMastraStream({
-      stream,
-      onChunk: mockOnChunk,
-    });
-
-    // The function should have called releaseLock in the finally block
-    expect(releaseLockSpy).toHaveBeenCalled();
-  });
-
-  it('should handle onChunk errors by logging them as JSON parse errors', async () => {
-    const testChunk: ChunkType = {
-      type: 'message',
-      runId: 'run-123',
-      from: 'agent',
-      payload: { text: 'first message' },
-    };
-
-    const sseData = `data: ${JSON.stringify(testChunk)}\n\n`;
-    const stream = createMockStream(sseData);
-
-    // Make the call to onChunk reject
-    mockOnChunk.mockRejectedValueOnce(new Error('onChunk error'));
-
-    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-    // Should not throw an error but handle it gracefully
-    await processMastraStream({
-      stream,
-      onChunk: mockOnChunk,
-    });
-
-    expect(mockOnChunk).toHaveBeenCalledTimes(1);
-    expect(mockOnChunk).toHaveBeenCalledWith(testChunk);
-
-    // Should log the onChunk error as a JSON parse error
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      '❌ JSON parse error:',
-      expect.any(Error),
-      'Data:',
-      JSON.stringify(testChunk),
-    );
-
-    consoleErrorSpy.mockRestore();
-  });
-
-  it('should handle stream read errors', async () => {
-    const errorMessage = 'Stream read error';
-    const stream = new ReadableStream({
-      start(controller) {
-        controller.error(new Error(errorMessage));
-      },
-    });
-
-    await expect(
-      processMastraStream({
-        stream,
-        onChunk: mockOnChunk,
-      }),
-    ).rejects.toThrow(errorMessage);
-
-    expect(mockOnChunk).not.toHaveBeenCalled();
-  });
-
-  it('should handle mixed valid and invalid data lines', async () => {
-    const validChunk1: ChunkType = {
-      type: 'message',
-      runId: 'run-123',
-      from: 'agent',
-      payload: { text: 'first valid message' },
-    };
-
-    const validChunk2: ChunkType = {
-      type: 'message',
-      runId: 'run-123',
-      from: 'agent',
-      payload: { text: 'second valid message' },
-    };
-
-    const sseData = `data: ${JSON.stringify(validChunk1)}\n\ndata: {invalid json}\n\ndata: ${JSON.stringify(validChunk2)}\n\ndata: [DONE]\n\n`;
-
-    const stream = createMockStream(sseData);
-    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-    await processMastraStream({
-      stream,
-      onChunk: mockOnChunk,
-    });
-
-    expect(mockOnChunk).toHaveBeenCalledTimes(2);
-    expect(mockOnChunk).toHaveBeenNthCalledWith(1, validChunk1);
-    expect(mockOnChunk).toHaveBeenNthCalledWith(2, validChunk2);
-
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      '❌ JSON parse error:',
-      expect.any(SyntaxError),
-      'Data:',
-      '{invalid json}',
-    );
-    expect(consoleSpy).toHaveBeenCalledWith('🏁 Stream finished');
-
-    consoleErrorSpy.mockRestore();
-    consoleSpy.mockRestore();
-  });
-
-  it('should handle data lines without "data: " prefix', async () => {
-    const testChunk: ChunkType = {
-      type: 'message',
-      runId: 'run-123',
-      from: 'agent',
-      payload: { text: 'valid message' },
-    };
-
-    const sseData = `some random line\n\ndata: ${JSON.stringify(testChunk)}\n\nanother line without prefix\n\n`;
-
-    const stream = createMockStream(sseData);
-
-    await processMastraStream({
-      stream,
-      onChunk: mockOnChunk,
-    });
-
-    expect(mockOnChunk).toHaveBeenCalledTimes(1);
-    expect(mockOnChunk).toHaveBeenCalledWith(testChunk);
-  });
-});

package/src/utils/process-mastra-stream.ts

@@ -1,49 +0,0 @@
-import type { ReadableStream } from 'stream/web';
-import type { ChunkType } from '@mastra/core/stream';
-
-export async function processMastraStream({
-  stream,
-  onChunk,
-}: {
-  stream: ReadableStream<Uint8Array>;
-  onChunk: (chunk: ChunkType) => Promise<void>;
-}) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = '';
-
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-
-      if (done) break;
-
-      // Decode the chunk and add to buffer
-      buffer += decoder.decode(value, { stream: true });
-
-      // Process complete SSE messages
-      const lines = buffer.split('\n\n');
-      buffer = lines.pop() || ''; // Keep incomplete line in buffer
-
-      for (const line of lines) {
-        if (line.startsWith('data: ')) {
-          const data = line.slice(6); // Remove 'data: '
-
-          if (data === '[DONE]') {
-            console.log('🏁 Stream finished');
-            return;
-          }
-
-          try {
-            const json = JSON.parse(data);
-            await onChunk(json);
-          } catch (error) {
-            console.error('❌ JSON parse error:', error, 'Data:', data);
-          }
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}

package/src/utils/zod-to-json-schema.ts

@@ -1,30 +0,0 @@
-import { z } from 'zod';
-import type { ZodType } from 'zod';
-import originalZodToJsonSchema from 'zod-to-json-schema';
-
-function isZodType(value: unknown): value is ZodType {
-  // Check if it's a Zod schema by looking for common Zod properties and methods
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    '_def' in value &&
-    'parse' in value &&
-    typeof (value as any).parse === 'function' &&
-    'safeParse' in value &&
-    typeof (value as any).safeParse === 'function'
-  );
-}
-
-export function zodToJsonSchema<T extends ZodType | any>(zodSchema: T) {
-  if (!isZodType(zodSchema)) {
-    return zodSchema;
-  }
-
-  if ('toJSONSchema' in z) {
-    const fn = 'toJSONSchema';
-    // @ts-expect-error Some nextjs compilation issue
-    return z[fn].call(z, zodSchema);
-  }
-
-  return originalZodToJsonSchema(zodSchema, { $refStrategy: 'none' });
-}

package/src/v2-messages.test.ts

@@ -1,180 +0,0 @@
-import type { MastraMessageV1, MastraMessageV2 } from '@mastra/core/memory';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { MastraClient } from './client';
-
-describe('V2 Message Format Support', () => {
-  let client: MastraClient;
-  const agentId = 'test-agent';
-
-  beforeEach(() => {
-    global.fetch = vi.fn();
-    client = new MastraClient({
-      baseUrl: 'http://localhost:3000',
-    });
-  });
-
-  it('should send v1 messages successfully', async () => {
-    const v1Messages: MastraMessageV1[] = [
-      {
-        id: 'msg-v1-1',
-        role: 'user',
-        content: 'Hello from v1!',
-        type: 'text',
-        createdAt: new Date(),
-        threadId: 'thread-123',
-        resourceId: 'resource-123',
-      },
-    ];
-
-    (global.fetch as any).mockResolvedValueOnce({
-      ok: true,
-      json: async () => v1Messages,
-    });
-
-    const result = await client.saveMessageToMemory({
-      agentId,
-      messages: v1Messages,
-    });
-
-    expect(result).toEqual(v1Messages);
-    expect(global.fetch).toHaveBeenCalledWith(
-      expect.stringContaining('/api/memory/save-messages'),
-      expect.objectContaining({
-        method: 'POST',
-        body: JSON.stringify({ agentId, messages: v1Messages }),
-      }),
-    );
-  });
-
-  it('should send v2 messages successfully', async () => {
-    const v2Messages: MastraMessageV2[] = [
-      {
-        id: 'msg-v2-1',
-        role: 'assistant',
-        createdAt: new Date(),
-        threadId: 'thread-123',
-        resourceId: 'resource-123',
-        content: {
-          format: 2,
-          parts: [{ type: 'text', text: 'Hello from v2!' }],
-          content: 'Hello from v2!',
-        },
-      },
-    ];
-
-    (global.fetch as any).mockResolvedValueOnce({
-      ok: true,
-      json: async () => v2Messages,
-    });
-
-    const result = await client.saveMessageToMemory({
-      agentId,
-      messages: v2Messages,
-    });
-
-    expect(result).toEqual(v2Messages);
-    expect(global.fetch).toHaveBeenCalledWith(
-      expect.stringContaining('/api/memory/save-messages'),
-      expect.objectContaining({
-        method: 'POST',
-        body: JSON.stringify({ agentId, messages: v2Messages }),
-      }),
-    );
-  });
-
-  it('should send mixed v1 and v2 messages successfully', async () => {
-    const mixedMessages: (MastraMessageV1 | MastraMessageV2)[] = [
-      {
-        id: 'msg-v1-1',
-        role: 'user',
-        content: 'Question in v1 format',
-        type: 'text',
-        createdAt: new Date(),
-        threadId: 'thread-123',
-        resourceId: 'resource-123',
-      },
-      {
-        id: 'msg-v2-1',
-        role: 'assistant',
-        createdAt: new Date(),
-        threadId: 'thread-123',
-        resourceId: 'resource-123',
-        content: {
-          format: 2,
-          parts: [
-            { type: 'text', text: 'Answer in v2 format' },
-            {
-              type: 'tool-invocation',
-              toolInvocation: {
-                state: 'result' as const,
-                toolCallId: 'call-123',
-                toolName: 'calculator',
-                args: { a: 1, b: 2 },
-                result: '3',
-              },
-            },
-          ],
-          toolInvocations: [
-            {
-              state: 'result' as const,
-              toolCallId: 'call-123',
-              toolName: 'calculator',
-              args: { a: 1, b: 2 },
-              result: '3',
-            },
-          ],
-        },
-      },
-    ];
-
-    (global.fetch as any).mockResolvedValueOnce({
-      ok: true,
-      json: async () => mixedMessages,
-    });
-
-    const result = await client.saveMessageToMemory({
-      agentId,
-      messages: mixedMessages,
-    });
-
-    expect(result).toEqual(mixedMessages);
-    expect(global.fetch).toHaveBeenCalledWith(
-      expect.stringContaining('/api/memory/save-messages'),
-      expect.objectContaining({
-        method: 'POST',
-        body: JSON.stringify({ agentId, messages: mixedMessages }),
-      }),
-    );
-  });
-
-  it('should handle v2 messages with attachments', async () => {
-    const v2MessageWithAttachments: MastraMessageV2 = {
-      id: 'msg-v2-att',
-      role: 'user',
-      createdAt: new Date(),
-      threadId: 'thread-123',
-      resourceId: 'resource-123',
-      content: {
-        format: 2,
-        parts: [
-          { type: 'text', text: 'Check out this image:' },
-          { type: 'file', data: 'data:image/png;base64,iVBORw0...', mimeType: 'image/png' },
-        ],
-        experimental_attachments: [{ url: 'data:image/png;base64,iVBORw0...', contentType: 'image/png' }],
-      },
-    };
-
-    (global.fetch as any).mockResolvedValueOnce({
-      ok: true,
-      json: async () => [v2MessageWithAttachments],
-    });
-
-    const result = await client.saveMessageToMemory({
-      agentId,
-      messages: [v2MessageWithAttachments],
-    });
-
-    expect(result).toHaveLength(1);
-    expect(result[0]).toEqual(v2MessageWithAttachments);
-  });
-});

package/tsconfig.build.json

@@ -1,9 +0,0 @@
-{
-  "extends": ["./tsconfig.json", "../../tsconfig.build.json"],
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "**/*.test.ts", "src/**/*.mock.ts"]
-}

package/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "../../tsconfig.node.json",
-  "include": ["src/**/*", "tsup.config.ts", "integration-tests/**/*"],
-  "exclude": ["node_modules", "integration-tests/node_modules", "src/example.ts", "**/*.test.ts"]
-}

package/tsup.config.ts

@@ -1,17 +0,0 @@
-import { generateTypes } from '@internal/types-builder';
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  format: ['esm', 'cjs'],
-  clean: true,
-  dts: false,
-  splitting: true,
-  treeshake: {
-    preset: 'smallest',
-  },
-  sourcemap: true,
-  onSuccess: async () => {
-    await generateTypes(process.cwd());
-  },
-});

package/vitest.config.js

@@ -1,8 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-    include: ['src/**/*.test.ts'],
-  },
-});