@mastra/client-js 0.0.0-switch-to-core-20250424015131 → 0.0.0-vector-query-sources-20250516172905

package/src/index.test.ts

@@ -1,7 +1,6 @@
-import type { MessageType } from '@mastra/core';
 import { describe, expect, beforeEach, it, vi } from 'vitest';
-
 import { MastraClient } from './client';
+import type { McpServerListResponse, ServerDetailInfo } from './types';
 
 // Mock fetch globally
 global.fetch = vi.fn();
@@ -237,6 +236,7 @@ describe('MastraClient Resources', () => {
         model: 'gpt-4',
         instructions: 'Test instructions',
         tools: {},
+        workflows: {},
       };
       mockFetchResponse(mockResponse);
 
@@ -489,7 +489,7 @@ describe('MastraClient Resources', () => {
       const result = await memoryThread.update({
         title: 'Updated Thread',
         metadata: { updated: true },
-        resourceid: 'test-resource',
+        resourceId: 'test-resource',
       });
       expect(result).toEqual(mockResponse);
       expect(global.fetch).toHaveBeenCalledWith(
@@ -536,6 +536,7 @@ describe('MastraClient Resources', () => {
           content: 'test',
           role: 'user' as const,
           threadId: 'test-thread',
+          resourceId: 'test-resource',
           createdAt: new Date('2025-03-26T10:40:55.116Z'),
         },
       ];
@@ -552,6 +553,35 @@ describe('MastraClient Resources', () => {
         }),
       );
     });
+
+    it('should get thread messages with limit', async () => {
+      const mockResponse = {
+        messages: [
+          {
+            id: '1',
+            content: 'test',
+            threadId,
+            role: 'user',
+            type: 'text',
+            resourceId: 'test-resource',
+            createdAt: new Date(),
+          },
+        ],
+        uiMessages: [],
+      };
+      mockFetchResponse(mockResponse);
+
+      const limit = 5;
+      const result = await memoryThread.getMessages({ limit });
+
+      expect(result).toEqual(mockResponse);
+      expect(global.fetch).toHaveBeenCalledWith(
+        `${clientOptions.baseUrl}/api/memory/threads/${threadId}/messages?agentId=${agentId}&limit=${limit}`,
+        expect.objectContaining({
+          headers: expect.objectContaining(clientOptions.headers),
+        }),
+      );
+    });
   });
 
   describe('Tool Resource', () => {
@@ -584,10 +614,10 @@ describe('MastraClient Resources', () => {
     it('should execute tool', async () => {
       const mockResponse = { data: 'test' };
       mockFetchResponse(mockResponse);
-      const result = await tool.execute({ data: '' });
+      const result = await tool.execute({ data: '', runId: 'test-run-id' });
       expect(result).toEqual(mockResponse);
       expect(global.fetch).toHaveBeenCalledWith(
-        `${clientOptions.baseUrl}/api/tools/test-tool/execute`,
+        `${clientOptions.baseUrl}/api/tools/test-tool/execute?runId=test-run-id`,
         expect.objectContaining({
           method: 'POST',
           headers: expect.objectContaining({
@@ -707,4 +737,94 @@ describe('MastraClient Resources', () => {
       );
     });
   });
+
+  describe('MCP Server Registry Client Methods', () => {
+    const mockServerInfo1 = {
+      id: 'mcp-server-1',
+      name: 'Test MCP Server 1',
+      version_detail: { version: '1.0.0', release_date: '2023-01-01T00:00:00Z', is_latest: true },
+    };
+    const mockServerInfo2 = {
+      id: 'mcp-server-2',
+      name: 'Test MCP Server 2',
+      version_detail: { version: '1.1.0', release_date: '2023-02-01T00:00:00Z', is_latest: true },
+    };
+
+    const mockServerDetail1: ServerDetailInfo = {
+      ...mockServerInfo1,
+      description: 'Detailed description for server 1',
+      package_canonical: 'npm',
+      packages: [{ registry_name: 'npm', name: '@example/server1', version: '1.0.0' }],
+      remotes: [{ transport_type: 'sse', url: 'http://localhost/sse1' }],
+    };
+
+    describe('getMcpServers()', () => {
+      it('should fetch a list of MCP servers', async () => {
+        const mockResponse: McpServerListResponse = {
+          servers: [mockServerInfo1, mockServerInfo2],
+          total_count: 2,
+          next: null,
+        };
+        mockFetchResponse(mockResponse);
+
+        const result = await client.getMcpServers();
+        expect(result).toEqual(mockResponse);
+        expect(global.fetch).toHaveBeenCalledWith(
+          `${clientOptions.baseUrl}/api/mcp/v0/servers`,
+          expect.objectContaining({
+            headers: expect.objectContaining(clientOptions.headers),
+          }),
+        );
+      });
+
+      it('should fetch MCP servers with limit and offset parameters', async () => {
+        const mockResponse: McpServerListResponse = {
+          servers: [mockServerInfo1],
+          total_count: 2,
+          next: '/api/mcp/v0/servers?limit=1&offset=1',
+        };
+        mockFetchResponse(mockResponse);
+
+        const result = await client.getMcpServers({ limit: 1, offset: 0 });
+        expect(result).toEqual(mockResponse);
+        expect(global.fetch).toHaveBeenCalledWith(
+          `${clientOptions.baseUrl}/api/mcp/v0/servers?limit=1&offset=0`,
+          expect.objectContaining({
+            headers: expect.objectContaining(clientOptions.headers),
+          }),
+        );
+      });
+    });
+
+    describe('getMcpServerDetails()', () => {
+      const serverId = 'mcp-server-1';
+
+      it('should fetch details for a specific MCP server', async () => {
+        mockFetchResponse(mockServerDetail1);
+
+        const result = await client.getMcpServerDetails(serverId);
+        expect(result).toEqual(mockServerDetail1);
+        expect(global.fetch).toHaveBeenCalledWith(
+          `${clientOptions.baseUrl}/api/mcp/v0/servers/${serverId}`,
+          expect.objectContaining({
+            headers: expect.objectContaining(clientOptions.headers),
+          }),
+        );
+      });
+
+      it('should fetch MCP server details with a version parameter', async () => {
+        mockFetchResponse(mockServerDetail1);
+        const version = '1.0.0';
+
+        const result = await client.getMcpServerDetails(serverId, { version });
+        expect(result).toEqual(mockServerDetail1);
+        expect(global.fetch).toHaveBeenCalledWith(
+          `${clientOptions.baseUrl}/api/mcp/v0/servers/${serverId}?version=${version}`,
+          expect.objectContaining({
+            headers: expect.objectContaining(clientOptions.headers),
+          }),
+        );
+      });
+    });
+  });
 });

package/src/resources/a2a.ts

@@ -0,0 +1,88 @@
+import type { TaskSendParams, TaskQueryParams, TaskIdParams, Task, AgentCard, JSONRPCResponse } from '@mastra/core/a2a';
+import type { ClientOptions } from '../types';
+import { BaseResource } from './base';
+
+/**
+ * Class for interacting with an agent via the A2A protocol
+ */
+export class A2A extends BaseResource {
+  constructor(
+    options: ClientOptions,
+    private agentId: string,
+  ) {
+    super(options);
+  }
+
+  /**
+   * Get the agent card with metadata about the agent
+   * @returns Promise containing the agent card information
+   */
+  async getCard(): Promise<AgentCard> {
+    return this.request(`/.well-known/${this.agentId}/agent.json`);
+  }
+
+  /**
+   * Send a message to the agent and get a response
+   * @param params - Parameters for the task
+   * @returns Promise containing the task response
+   */
+  async sendMessage(params: TaskSendParams): Promise<{ task: Task }> {
+    const response = await this.request<JSONRPCResponse<Task>>(`/a2a/${this.agentId}`, {
+      method: 'POST',
+      body: {
+        method: 'tasks/send',
+        params,
+      },
+    });
+
+    return { task: response.result! };
+  }
+
+  /**
+   * Get the status and result of a task
+   * @param params - Parameters for querying the task
+   * @returns Promise containing the task response
+   */
+  async getTask(params: TaskQueryParams): Promise<Task> {
+    const response = await this.request<JSONRPCResponse<Task>>(`/a2a/${this.agentId}`, {
+      method: 'POST',
+      body: {
+        method: 'tasks/get',
+        params,
+      },
+    });
+
+    return response.result!;
+  }
+
+  /**
+   * Cancel a running task
+   * @param params - Parameters identifying the task to cancel
+   * @returns Promise containing the task response
+   */
+  async cancelTask(params: TaskIdParams): Promise<{ task: Task }> {
+    return this.request(`/a2a/${this.agentId}`, {
+      method: 'POST',
+      body: {
+        method: 'tasks/cancel',
+        params,
+      },
+    });
+  }
+
+  /**
+   * Send a message and subscribe to streaming updates (not fully implemented)
+   * @param params - Parameters for the task
+   * @returns Promise containing the task response
+   */
+  async sendAndSubscribe(params: TaskSendParams): Promise<Response> {
+    return this.request(`/a2a/${this.agentId}`, {
+      method: 'POST',
+      body: {
+        method: 'tasks/sendSubscribe',
+        params,
+      },
+      stream: true,
+    });
+  }
+}

package/src/resources/agent.ts

@@ -1,8 +1,8 @@
+import { processDataStream } from '@ai-sdk/ui-utils';
 import type { GenerateReturn } from '@mastra/core';
 import type { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
-import { zodToJsonSchema } from 'zod-to-json-schema';
-import { processDataStream } from '@ai-sdk/ui-utils';
+import { zodToJsonSchema } from '../utils/zod-to-json-schema';
 
 import type {
   GenerateParams,
@@ -14,29 +14,7 @@ import type {
 } from '../types';
 
 import { BaseResource } from './base';
-
-export class AgentTool extends BaseResource {
-  constructor(
-    options: ClientOptions,
-    private agentId: string,
-    private toolId: string,
-  ) {
-    super(options);
-  }
-
-  /**
-   * Executes a specific tool for an agent
-   * @param params - Parameters required for tool execution
-   * @returns Promise containing tool execution results
-   */
-  /** @deprecated use CreateRun/startRun */
-  execute(params: { data: any }): Promise<any> {
-    return this.request(`/api/agents/${this.agentId}/tools/${this.toolId}/execute`, {
-      method: 'POST',
-      body: params,
-    });
-  }
-}
+import type { RuntimeContext } from '@mastra/core/di';
 
 export class AgentVoice extends BaseResource {
   constructor(
@@ -70,7 +48,7 @@ export class AgentVoice extends BaseResource {
    * @param options - Optional provider-specific options
    * @returns Promise containing the transcribed text
    */
-  listen(audio: Blob, options?: Record<string, any>): Promise<Response> {
+  listen(audio: Blob, options?: Record<string, any>): Promise<{ text: string }> {
     const formData = new FormData();
     formData.append('audio', audio);
 
@@ -122,11 +100,9 @@ export class Agent extends BaseResource {
   ): Promise<GenerateReturn<T>> {
     const processedParams = {
       ...params,
-      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
-      experimental_output:
-        params.experimental_output instanceof ZodSchema
-          ? zodToJsonSchema(params.experimental_output)
-          : params.experimental_output,
+      output: params.output ? zodToJsonSchema(params.output) : undefined,
+      experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : undefined,
+      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : undefined,
     };
 
     return this.request(`/api/agents/${this.agentId}/generate`, {
@@ -149,11 +125,9 @@ export class Agent extends BaseResource {
   > {
     const processedParams = {
       ...params,
-      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
-      experimental_output:
-        params.experimental_output instanceof ZodSchema
-          ? zodToJsonSchema(params.experimental_output)
-          : params.experimental_output,
+      output: params.output ? zodToJsonSchema(params.output) : undefined,
+      experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : undefined,
+      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : undefined,
     };
 
     const response: Response & {
@@ -187,6 +161,23 @@ export class Agent extends BaseResource {
     return this.request(`/api/agents/${this.agentId}/tools/${toolId}`);
   }
 
+  /**
+   * Executes a tool for the agent
+   * @param toolId - ID of the tool to execute
+   * @param params - Parameters required for tool execution
+   * @returns Promise containing the tool execution results
+   */
+  executeTool(toolId: string, params: { data: any; runtimeContext?: RuntimeContext }): Promise<any> {
+    const body = {
+      data: params.data,
+      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : undefined,
+    };
+    return this.request(`/api/agents/${this.agentId}/tools/${toolId}/execute`, {
+      method: 'POST',
+      body,
+    });
+  }
+
   /**
    * Retrieves evaluation results for the agent
    * @returns Promise containing agent evaluations

package/src/resources/base.ts

@@ -1,4 +1,4 @@
-import type { RequestFunction, RequestOptions, ClientOptions } from '../types';
+import type { RequestOptions, ClientOptions } from '../types';
 
 export class BaseResource {
   readonly options: ClientOptions;
@@ -21,7 +21,7 @@ export class BaseResource {
 
     for (let attempt = 0; attempt <= retries; attempt++) {
       try {
-        const response = await fetch(`${baseUrl}${path}`, {
+        const response = await fetch(`${baseUrl.replace(/\/$/, '')}${path}`, {
           ...options,
           headers: {
             ...headers,

package/src/resources/index.ts

@@ -5,3 +5,6 @@ export * from './vector';
 export * from './workflow';
 export * from './tool';
 export * from './base';
+export * from './vnext-workflow';
+export * from './a2a';
+export * from './mcp-tool';

package/src/resources/mcp-tool.ts

@@ -0,0 +1,48 @@
+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.ts

@@ -1,6 +1,11 @@
 import type { StorageThreadType } from '@mastra/core';
 
-import type { GetMemoryThreadMessagesResponse, ClientOptions, UpdateMemoryThreadParams } from '../types';
+import type {
+  GetMemoryThreadMessagesResponse,
+  ClientOptions,
+  UpdateMemoryThreadParams,
+  GetMemoryThreadMessagesParams,
+} from '../types';
 
 import { BaseResource } from './base';
 
@@ -45,9 +50,14 @@ export class MemoryThread extends BaseResource {
 
   /**
    * Retrieves messages associated with the thread
+   * @param params - Optional parameters including limit for number of messages to retrieve
    * @returns Promise containing thread messages and UI messages
    */
-  getMessages(): Promise<GetMemoryThreadMessagesResponse> {
-    return this.request(`/api/memory/threads/${this.threadId}/messages?agentId=${this.agentId}`);
+  getMessages(params?: GetMemoryThreadMessagesParams): Promise<GetMemoryThreadMessagesResponse> {
+    const query = new URLSearchParams({
+      agentId: this.agentId,
+      ...(params?.limit ? { limit: params.limit.toString() } : {}),
+    });
+    return this.request(`/api/memory/threads/${this.threadId}/messages?${query.toString()}`);
   }
 }

package/src/resources/network.ts

@@ -1,12 +1,12 @@
+import { processDataStream } from '@ai-sdk/ui-utils';
 import type { GenerateReturn } from '@mastra/core';
 import type { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
-import { zodToJsonSchema } from 'zod-to-json-schema';
+import { zodToJsonSchema } from '../utils/zod-to-json-schema';
 
 import type { GenerateParams, ClientOptions, StreamParams, GetNetworkResponse } from '../types';
 
 import { BaseResource } from './base';
-import { processDataStream } from '@ai-sdk/ui-utils';
 
 export class Network extends BaseResource {
   constructor(
@@ -34,11 +34,8 @@ export class Network extends BaseResource {
   ): Promise<GenerateReturn<T>> {
     const processedParams = {
       ...params,
-      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
-      experimental_output:
-        params.experimental_output instanceof ZodSchema
-          ? zodToJsonSchema(params.experimental_output)
-          : params.experimental_output,
+      output: zodToJsonSchema(params.output),
+      experimental_output: zodToJsonSchema(params.experimental_output),
     };
 
     return this.request(`/api/networks/${this.networkId}/generate`, {
@@ -61,11 +58,8 @@ export class Network extends BaseResource {
   > {
     const processedParams = {
       ...params,
-      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
-      experimental_output:
-        params.experimental_output instanceof ZodSchema
-          ? zodToJsonSchema(params.experimental_output)
-          : params.experimental_output,
+      output: zodToJsonSchema(params.output),
+      experimental_output: zodToJsonSchema(params.experimental_output),
     };
 
     const response: Response & {

package/src/resources/tool.ts

@@ -1,3 +1,4 @@
+import type { RuntimeContext } from '@mastra/core/di';
 import type { GetToolResponse, ClientOptions } from '../types';
 
 import { BaseResource } from './base';
@@ -23,10 +24,21 @@ export class Tool extends BaseResource {
    * @param params - Parameters required for tool execution
    * @returns Promise containing the tool execution results
    */
-  execute(params: { data: any }): Promise<any> {
-    return this.request(`/api/tools/${this.toolId}/execute`, {
+  execute(params: { data: any; runId?: string; runtimeContext?: RuntimeContext }): Promise<any> {
+    const url = new URLSearchParams();
+
+    if (params.runId) {
+      url.set('runId', params.runId);
+    }
+
+    const body = {
+      data: params.data,
+      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : undefined,
+    };
+
+    return this.request(`/api/tools/${this.toolId}/execute?${url.toString()}`, {
       method: 'POST',
-      body: params,
+      body,
     });
   }
 }