@mastra/client-js 0.10.22-alpha.3 → 0.10.22-alpha.5

package/src/types.ts

@@ -11,7 +11,14 @@ import type {
   PaginationInfo,
   MastraMessageV2,
 } from '@mastra/core';
-import type { AgentGenerateOptions, AgentStreamOptions, ToolsInput, UIMessageWithMetadata } from '@mastra/core/agent';
+import type {
+  AgentExecutionOptions,
+  AgentGenerateOptions,
+  AgentStreamOptions,
+  ToolsInput,
+  UIMessageWithMetadata,
+} from '@mastra/core/agent';
+import type { MessageListInput } from '@mastra/core/agent/message-list';
 import type { BaseLogMessage, LogLevel } from '@mastra/core/logger';
 
 import type { MCPToolType, ServerInfo } from '@mastra/core/mcp';
@@ -65,6 +72,7 @@ export interface GetAgentResponse {
   workflows: Record<string, GetWorkflowResponse>;
   provider: string;
   modelId: string;
+  modelVersion: string;
   defaultGenerateOptions: WithoutMethods<AgentGenerateOptions>;
   defaultStreamOptions: WithoutMethods<AgentStreamOptions>;
 }
@@ -89,6 +97,13 @@ export type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefin
   Omit<AgentStreamOptions<T>, 'output' | 'experimental_output' | 'runtimeContext' | 'clientTools' | 'abortSignal'>
 >;
 
+export type StreamVNextParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
+  messages: MessageListInput;
+  output?: T;
+  runtimeContext?: RuntimeContext | Record<string, any>;
+  clientTools?: ToolsInput;
+} & WithoutMethods<Omit<AgentExecutionOptions<T>, 'output' | 'runtimeContext' | 'clientTools' | 'options'>>;
+
 export type UpdateModelParams = {
   modelId: string;
   provider: 'openai' | 'anthropic' | 'groq' | 'xai' | 'google';

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

@@ -0,0 +1,353 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { processMastraStream } from './process-mastra-stream';
+import type { ChunkType } from '@mastra/core/stream';
+import { ReadableStream } from 'stream/web';
+
+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

@@ -0,0 +1,49 @@
+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();
+  }
+}