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

package/src/resources/base.ts

@@ -1,77 +0,0 @@
-import type { RequestOptions, ClientOptions } from '../types';
-
-export class BaseResource {
-  readonly options: ClientOptions;
-
-  constructor(options: ClientOptions) {
-    this.options = options;
-  }
-
-  /**
-   * Makes an HTTP request to the API with retries and exponential backoff
-   * @param path - The API endpoint path
-   * @param options - Optional request configuration
-   * @returns Promise containing the response data
-   */
-  public async request<T>(path: string, options: RequestOptions = {}): Promise<T> {
-    let lastError: Error | null = null;
-    const { baseUrl, retries = 3, backoffMs = 100, maxBackoffMs = 1000, headers = {}, credentials } = this.options;
-
-    let delay = backoffMs;
-
-    for (let attempt = 0; attempt <= retries; attempt++) {
-      try {
-        const response = await fetch(`${baseUrl.replace(/\/$/, '')}${path}`, {
-          ...options,
-          headers: {
-            ...(options.body &&
-            !(options.body instanceof FormData) &&
-            (options.method === 'POST' || options.method === 'PUT')
-              ? { 'content-type': 'application/json' }
-              : {}),
-            ...headers,
-            ...options.headers,
-            // TODO: Bring this back once we figure out what we/users need to do to make this work with cross-origin requests
-            // 'x-mastra-client-type': 'js',
-          },
-          signal: this.options.abortSignal,
-          credentials: options.credentials ?? credentials,
-          body:
-            options.body instanceof FormData ? options.body : options.body ? JSON.stringify(options.body) : undefined,
-        });
-
-        if (!response.ok) {
-          const errorBody = await response.text();
-          let errorMessage = `HTTP error! status: ${response.status}`;
-          try {
-            const errorJson = JSON.parse(errorBody);
-            errorMessage += ` - ${JSON.stringify(errorJson)}`;
-          } catch {
-            if (errorBody) {
-              errorMessage += ` - ${errorBody}`;
-            }
-          }
-          throw new Error(errorMessage);
-        }
-
-        if (options.stream) {
-          return response as unknown as T;
-        }
-
-        const data = await response.json();
-        return data as T;
-      } catch (error) {
-        lastError = error as Error;
-
-        if (attempt === retries) {
-          break;
-        }
-
-        await new Promise(resolve => setTimeout(resolve, delay));
-        delay = Math.min(delay * 2, maxBackoffMs);
-      }
-    }
-
-    throw lastError || new Error('Request failed');
-  }
-}

package/src/resources/index.ts

@@ -1,11 +0,0 @@
-export * from './agent';
-export * from './network';
-export * from './memory-thread';
-export * from './vector';
-export * from './legacy-workflow';
-export * from './tool';
-export * from './base';
-export * from './workflow';
-export * from './a2a';
-export * from './mcp-tool';
-export * from './observability';

package/src/resources/legacy-workflow.ts

@@ -1,242 +0,0 @@
-import type {
-  ClientOptions,
-  LegacyWorkflowRunResult,
-  GetLegacyWorkflowRunsResponse,
-  GetWorkflowRunsParams,
-  GetLegacyWorkflowResponse,
-} from '../types';
-
-import { BaseResource } from './base';
-
-const RECORD_SEPARATOR = '\x1E';
-
-export class LegacyWorkflow extends BaseResource {
-  constructor(
-    options: ClientOptions,
-    private workflowId: string,
-  ) {
-    super(options);
-  }
-
-  /**
-   * Retrieves details about the legacy workflow
-   * @returns Promise containing legacy workflow details including steps and graphs
-   */
-  details(): Promise<GetLegacyWorkflowResponse> {
-    return this.request(`/api/workflows/legacy/${this.workflowId}`);
-  }
-
-  /**
-   * Retrieves all runs for a legacy workflow
-   * @param params - Parameters for filtering runs
-   * @returns Promise containing legacy workflow runs array
-   */
-  runs(params?: GetWorkflowRunsParams): Promise<GetLegacyWorkflowRunsResponse> {
-    const searchParams = new URLSearchParams();
-    if (params?.fromDate) {
-      searchParams.set('fromDate', params.fromDate.toISOString());
-    }
-    if (params?.toDate) {
-      searchParams.set('toDate', params.toDate.toISOString());
-    }
-    if (params?.limit) {
-      searchParams.set('limit', String(params.limit));
-    }
-    if (params?.offset) {
-      searchParams.set('offset', String(params.offset));
-    }
-    if (params?.resourceId) {
-      searchParams.set('resourceId', params.resourceId);
-    }
-
-    if (searchParams.size) {
-      return this.request(`/api/workflows/legacy/${this.workflowId}/runs?${searchParams}`);
-    } else {
-      return this.request(`/api/workflows/legacy/${this.workflowId}/runs`);
-    }
-  }
-
-  /**
-   * Creates a new legacy workflow run
-   * @returns Promise containing the generated run ID
-   */
-  createRun(params?: { runId?: string }): Promise<{ runId: string }> {
-    const searchParams = new URLSearchParams();
-
-    if (!!params?.runId) {
-      searchParams.set('runId', params.runId);
-    }
-
-    return this.request(`/api/workflows/legacy/${this.workflowId}/create-run?${searchParams.toString()}`, {
-      method: 'POST',
-    });
-  }
-
-  /**
-   * Starts a legacy workflow run synchronously without waiting for the workflow to complete
-   * @param params - Object containing the runId and triggerData
-   * @returns Promise containing success message
-   */
-  start(params: { runId: string; triggerData: Record<string, any> }): Promise<{ message: string }> {
-    return this.request(`/api/workflows/legacy/${this.workflowId}/start?runId=${params.runId}`, {
-      method: 'POST',
-      body: params?.triggerData,
-    });
-  }
-
-  /**
-   * Resumes a suspended legacy workflow step synchronously without waiting for the workflow to complete
-   * @param stepId - ID of the step to resume
-   * @param runId - ID of the legacy workflow run
-   * @param context - Context to resume the legacy workflow with
-   * @returns Promise containing the legacy workflow resume results
-   */
-  resume({
-    stepId,
-    runId,
-    context,
-  }: {
-    stepId: string;
-    runId: string;
-    context: Record<string, any>;
-  }): Promise<{ message: string }> {
-    return this.request(`/api/workflows/legacy/${this.workflowId}/resume?runId=${runId}`, {
-      method: 'POST',
-      body: {
-        stepId,
-        context,
-      },
-    });
-  }
-
-  /**
-   * Starts a workflow run asynchronously and returns a promise that resolves when the workflow is complete
-   * @param params - Object containing the optional runId and triggerData
-   * @returns Promise containing the workflow execution results
-   */
-  startAsync(params: { runId?: string; triggerData: Record<string, any> }): Promise<LegacyWorkflowRunResult> {
-    const searchParams = new URLSearchParams();
-
-    if (!!params?.runId) {
-      searchParams.set('runId', params.runId);
-    }
-
-    return this.request(`/api/workflows/legacy/${this.workflowId}/start-async?${searchParams.toString()}`, {
-      method: 'POST',
-      body: params?.triggerData,
-    });
-  }
-
-  /**
-   * Resumes a suspended legacy workflow step asynchronously and returns a promise that resolves when the workflow is complete
-   * @param params - Object containing the runId, stepId, and context
-   * @returns Promise containing the workflow resume results
-   */
-  resumeAsync(params: {
-    runId: string;
-    stepId: string;
-    context: Record<string, any>;
-  }): Promise<LegacyWorkflowRunResult> {
-    return this.request(`/api/workflows/legacy/${this.workflowId}/resume-async?runId=${params.runId}`, {
-      method: 'POST',
-      body: {
-        stepId: params.stepId,
-        context: params.context,
-      },
-    });
-  }
-
-  /**
-   * Creates an async generator that processes a readable stream and yields records
-   * separated by the Record Separator character (\x1E)
-   *
-   * @param stream - The readable stream to process
-   * @returns An async generator that yields parsed records
-   */
-  private async *streamProcessor(stream: ReadableStream): AsyncGenerator<LegacyWorkflowRunResult, void, unknown> {
-    const reader = stream.getReader();
-
-    // Track if we've finished reading from the stream
-    let doneReading = false;
-    // Buffer to accumulate partial chunks
-    let buffer = '';
-
-    try {
-      while (!doneReading) {
-        // Read the next chunk from the stream
-        const { done, value } = await reader.read();
-        doneReading = done;
-
-        // Skip processing if we're done and there's no value
-        if (done && !value) continue;
-
-        try {
-          // Decode binary data to text
-          const decoded = value ? new TextDecoder().decode(value) : '';
-
-          // Split the combined buffer and new data by record separator
-          const chunks = (buffer + decoded).split(RECORD_SEPARATOR);
-
-          // The last chunk might be incomplete, so save it for the next iteration
-          buffer = chunks.pop() || '';
-
-          // Process complete chunks
-          for (const chunk of chunks) {
-            if (chunk) {
-              // Only process non-empty chunks
-              if (typeof chunk === 'string') {
-                try {
-                  const parsedChunk = JSON.parse(chunk);
-                  yield parsedChunk;
-                } catch {
-                  // Silently ignore parsing errors to maintain stream processing
-                  // This allows the stream to continue even if one record is malformed
-                }
-              }
-            }
-          }
-        } catch {
-          // Silently ignore parsing errors to maintain stream processing
-          // This allows the stream to continue even if one record is malformed
-        }
-      }
-
-      // Process any remaining data in the buffer after stream is done
-      if (buffer) {
-        try {
-          yield JSON.parse(buffer);
-        } catch {
-          // Ignore parsing error for final chunk
-        }
-      }
-    } finally {
-      // Always ensure we clean up the reader
-      reader.cancel().catch(() => {
-        // Ignore cancel errors
-      });
-    }
-  }
-
-  /**
-   * Watches legacy workflow transitions in real-time
-   * @param runId - Optional run ID to filter the watch stream
-   * @returns AsyncGenerator that yields parsed records from the legacy workflow watch stream
-   */
-  async watch({ runId }: { runId?: string }, onRecord: (record: LegacyWorkflowRunResult) => void) {
-    const response: Response = await this.request(`/api/workflows/legacy/${this.workflowId}/watch?runId=${runId}`, {
-      stream: true,
-    });
-
-    if (!response.ok) {
-      throw new Error(`Failed to watch legacy workflow: ${response.statusText}`);
-    }
-
-    if (!response.body) {
-      throw new Error('Response body is null');
-    }
-
-    for await (const record of this.streamProcessor(response.body)) {
-      onRecord(record);
-    }
-  }
-}

package/src/resources/mcp-tool.ts

@@ -1,48 +0,0 @@
-import type { RuntimeContext } from '@mastra/core/runtime-context';
-import type { ClientOptions, McpToolInfo } from '../types';
-import { BaseResource } from './base';
-
-/**
- * Represents a specific tool available on a specific MCP server.
- * Provides methods to get details and execute the tool.
- */
-export class MCPTool extends BaseResource {
-  private serverId: string;
-  private toolId: string;
-
-  constructor(options: ClientOptions, serverId: string, toolId: string) {
-    super(options);
-    this.serverId = serverId;
-    this.toolId = toolId;
-  }
-
-  /**
-   * Retrieves details about this specific tool from the MCP server.
-   * @returns Promise containing the tool's information (name, description, schema).
-   */
-  details(): Promise<McpToolInfo> {
-    return this.request(`/api/mcp/${this.serverId}/tools/${this.toolId}`);
-  }
-
-  /**
-   * Executes this specific tool on the MCP server.
-   * @param params - Parameters for tool execution, including data/args and optional runtimeContext.
-   * @returns Promise containing the result of the tool execution.
-   */
-  execute(params: { data?: any; runtimeContext?: RuntimeContext }): Promise<any> {
-    const body: any = {};
-    if (params.data !== undefined) body.data = params.data;
-    // If none of data, args the body might be empty or just contain runtimeContext.
-    // The handler will look for these, so an empty args object might be appropriate if that's the intent.
-    // else body.data = {}; // Or let it be empty if no specific input fields are used
-
-    if (params.runtimeContext !== undefined) {
-      body.runtimeContext = params.runtimeContext;
-    }
-
-    return this.request(`/api/mcp/${this.serverId}/tools/${this.toolId}/execute`, {
-      method: 'POST',
-      body: Object.keys(body).length > 0 ? body : undefined,
-    });
-  }
-}

package/src/resources/memory-thread.test.ts

@@ -1,285 +0,0 @@
-import { describe, expect, beforeEach, it, vi } from 'vitest';
-import type { ClientOptions } from '../types';
-import { MemoryThread } from './memory-thread';
-
-// Mock fetch globally
-global.fetch = vi.fn();
-
-describe('MemoryThread', () => {
-  let thread: MemoryThread;
-  const clientOptions: ClientOptions = {
-    baseUrl: 'http://localhost:4111',
-    headers: {
-      Authorization: 'Bearer test-key',
-    },
-  };
-  const threadId = 'test-thread-id';
-  const agentId = 'test-agent-id';
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    thread = new MemoryThread(clientOptions, threadId, agentId);
-  });
-
-  const mockFetchResponse = (data: any) => {
-    (global.fetch as any).mockResolvedValueOnce({
-      ok: true,
-      status: 200,
-      json: async () => data,
-      headers: new Headers({
-        'content-type': 'application/json',
-      }),
-    });
-  };
-
-  describe('get', () => {
-    it('should retrieve thread details', async () => {
-      const mockThread = {
-        id: threadId,
-        title: 'Test Thread',
-        metadata: { test: true },
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-      };
-
-      mockFetchResponse(mockThread);
-
-      const result = await thread.get();
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/threads/${threadId}?agentId=${agentId}`,
-        expect.objectContaining({
-          headers: expect.objectContaining({
-            Authorization: 'Bearer test-key',
-          }),
-        }),
-      );
-      expect(result).toEqual(mockThread);
-    });
-  });
-
-  describe('update', () => {
-    it('should update thread properties', async () => {
-      const updateParams = {
-        title: 'Updated Title',
-        metadata: { updated: true },
-        resourceid: 'resource-1',
-      };
-
-      const mockUpdatedThread = {
-        id: threadId,
-        ...updateParams,
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-      };
-
-      mockFetchResponse(mockUpdatedThread);
-
-      const result = await thread.update(updateParams);
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/threads/${threadId}?agentId=${agentId}`,
-        expect.objectContaining({
-          method: 'PATCH',
-          headers: expect.objectContaining({
-            Authorization: 'Bearer test-key',
-          }),
-          body: JSON.stringify(updateParams),
-        }),
-      );
-      expect(result).toEqual(mockUpdatedThread);
-    });
-  });
-
-  describe('delete', () => {
-    it('should delete the thread', async () => {
-      const mockResponse = { result: 'Thread deleted' };
-      mockFetchResponse(mockResponse);
-
-      const result = await thread.delete();
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/threads/${threadId}?agentId=${agentId}`,
-        expect.objectContaining({
-          method: 'DELETE',
-          headers: expect.objectContaining({
-            Authorization: 'Bearer test-key',
-          }),
-        }),
-      );
-      expect(result).toEqual(mockResponse);
-    });
-  });
-
-  describe('getMessages', () => {
-    it('should retrieve thread messages', async () => {
-      const mockMessages = {
-        messages: [
-          { id: 'msg-1', content: 'Hello', role: 'user' },
-          { id: 'msg-2', content: 'Hi there', role: 'assistant' },
-        ],
-        uiMessages: [
-          { id: 'msg-1', content: 'Hello', role: 'user' },
-          { id: 'msg-2', content: 'Hi there', role: 'assistant' },
-        ],
-      };
-
-      mockFetchResponse(mockMessages);
-
-      const result = await thread.getMessages();
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/threads/${threadId}/messages?agentId=${agentId}`,
-        expect.objectContaining({
-          headers: expect.objectContaining({
-            Authorization: 'Bearer test-key',
-          }),
-        }),
-      );
-      expect(result).toEqual(mockMessages);
-    });
-
-    it('should retrieve thread messages with limit', async () => {
-      const mockMessages = {
-        messages: [{ id: 'msg-1', content: 'Hello', role: 'user' }],
-        uiMessages: [{ id: 'msg-1', content: 'Hello', role: 'user' }],
-      };
-
-      mockFetchResponse(mockMessages);
-
-      const result = await thread.getMessages({ limit: 5 });
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/threads/${threadId}/messages?agentId=${agentId}&limit=5`,
-        expect.objectContaining({
-          headers: expect.objectContaining({
-            Authorization: 'Bearer test-key',
-          }),
-        }),
-      );
-      expect(result).toEqual(mockMessages);
-    });
-  });
-
-  describe('deleteMessages', () => {
-    it('should delete a single message by string ID', async () => {
-      const messageId = 'test-message-id';
-      const mockResponse = { success: true, message: '1 message deleted successfully' };
-
-      mockFetchResponse(mockResponse);
-
-      const result = await thread.deleteMessages(messageId);
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/messages/delete?agentId=${agentId}`,
-        expect.objectContaining({
-          method: 'POST',
-          headers: expect.objectContaining({
-            'content-type': 'application/json',
-            Authorization: 'Bearer test-key',
-          }),
-          body: JSON.stringify({ messageIds: messageId }),
-        }),
-      );
-      expect(result).toEqual(mockResponse);
-    });
-
-    it('should delete multiple messages by array of string IDs', async () => {
-      const messageIds = ['msg-1', 'msg-2', 'msg-3'];
-      const mockResponse = { success: true, message: '3 messages deleted successfully' };
-
-      mockFetchResponse(mockResponse);
-
-      const result = await thread.deleteMessages(messageIds);
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/messages/delete?agentId=${agentId}`,
-        expect.objectContaining({
-          method: 'POST',
-          headers: expect.objectContaining({
-            'content-type': 'application/json',
-            Authorization: 'Bearer test-key',
-          }),
-          body: JSON.stringify({ messageIds }),
-        }),
-      );
-      expect(result).toEqual(mockResponse);
-    });
-
-    it('should delete a message by object with id property', async () => {
-      const messageObj = { id: 'test-message-id' };
-      const mockResponse = { success: true, message: '1 message deleted successfully' };
-
-      mockFetchResponse(mockResponse);
-
-      const result = await thread.deleteMessages(messageObj);
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/messages/delete?agentId=${agentId}`,
-        expect.objectContaining({
-          method: 'POST',
-          headers: expect.objectContaining({
-            'content-type': 'application/json',
-            Authorization: 'Bearer test-key',
-          }),
-          body: JSON.stringify({ messageIds: messageObj }),
-        }),
-      );
-      expect(result).toEqual(mockResponse);
-    });
-
-    it('should delete messages by array of objects', async () => {
-      const messageObjs = [{ id: 'msg-1' }, { id: 'msg-2' }];
-      const mockResponse = { success: true, message: '2 messages deleted successfully' };
-
-      mockFetchResponse(mockResponse);
-
-      const result = await thread.deleteMessages(messageObjs);
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        `http://localhost:4111/api/memory/messages/delete?agentId=${agentId}`,
-        expect.objectContaining({
-          method: 'POST',
-          headers: expect.objectContaining({
-            'content-type': 'application/json',
-            Authorization: 'Bearer test-key',
-          }),
-          body: JSON.stringify({ messageIds: messageObjs }),
-        }),
-      );
-      expect(result).toEqual(mockResponse);
-    });
-
-    it('should handle empty array', async () => {
-      const messageIds: string[] = [];
-
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: false,
-        status: 400,
-        statusText: 'Bad Request',
-        json: async () => ({ error: 'messageIds array cannot be empty' }),
-        headers: new Headers({
-          'content-type': 'application/json',
-        }),
-      });
-
-      await expect(thread.deleteMessages(messageIds)).rejects.toThrow();
-    });
-
-    it('should handle bulk delete errors', async () => {
-      const messageIds = ['msg-1', 'msg-2'];
-
-      (global.fetch as any).mockResolvedValueOnce({
-        ok: false,
-        status: 500,
-        statusText: 'Internal Server Error',
-        json: async () => ({ error: 'Database error' }),
-        headers: new Headers({
-          'content-type': 'application/json',
-        }),
-      });
-
-      await expect(thread.deleteMessages(messageIds)).rejects.toThrow();
-    });
-  });
-});