@mastra/client-js 0.0.0-fix-message-embedding-20250506021742 → 0.0.0-fix-generate-title-20250616171351

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.0.0-fix-message-embedding-20250506021742",
+  "version": "0.0.0-fix-generate-title-20250616171351",
   "description": "The official TypeScript library for the Mastra Client API",
   "author": "",
   "type": "module",
@@ -19,30 +19,35 @@
     },
     "./package.json": "./package.json"
   },
-  "repository": "github:mastra-ai/client-js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mastra-ai/mastra.git",
+    "directory": "client-sdks/client-js"
+  },
+  "homepage": "https://github.com/mastra-ai/mastra/tree/main/client-sdks/client-js#readme",
   "license": "Elastic-2.0",
   "dependencies": {
     "@ag-ui/client": "^0.0.27",
-    "@ai-sdk/ui-utils": "^1.1.19",
+    "@ai-sdk/ui-utils": "^1.2.11",
     "json-schema": "^0.4.0",
     "rxjs": "7.8.1",
-    "zod": "^3.24.2",
-    "zod-to-json-schema": "^3.24.3",
-    "@mastra/core": "0.0.0-fix-message-embedding-20250506021742"
+    "zod": "^3.25.57",
+    "zod-to-json-schema": "^3.24.5",
+    "@mastra/core": "0.0.0-fix-generate-title-20250616171351"
   },
   "peerDependencies": {
-    "zod": "^3.24.2"
+    "zod": "^3.0.0"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.26.9",
-    "@babel/preset-typescript": "^7.27.0",
+    "@babel/preset-env": "^7.27.2",
+    "@babel/preset-typescript": "^7.27.1",
     "@tsconfig/recommended": "^1.0.8",
     "@types/json-schema": "^7.0.15",
-    "@types/node": "^20.17.27",
-    "tsup": "^8.4.0",
-    "typescript": "^5.8.2",
-    "vitest": "^3.1.2",
-    "@internal/lint": "0.0.0-fix-message-embedding-20250506021742"
+    "@types/node": "^20.19.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.3",
+    "@internal/lint": "0.0.0-fix-generate-title-20250616171351"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts --clean --treeshake=smallest --splitting",

package/src/adapters/agui.test.ts

@@ -91,6 +91,17 @@ describe('convertMessagesToMastraMessages', () => {
           },
         ],
       },
+      {
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: 'tool-call-1',
+            toolName: 'getWeather',
+            result: { location: 'San Francisco' },
+          },
+        ],
+      },
     ]);
   });
 
@@ -143,12 +154,6 @@ describe('convertMessagesToMastraMessages', () => {
           },
         ],
       },
-      {
-        id: '3',
-        role: 'tool',
-        toolCallId: 'tool-call-1',
-        content: '{"temperature":72,"unit":"F"}',
-      },
       {
         id: '4',
         role: 'assistant',
@@ -162,6 +167,14 @@ describe('convertMessagesToMastraMessages', () => {
     expect(result[0].role).toBe('user');
     expect(result[1].role).toBe('assistant');
     expect(result[2].role).toBe('tool');
+    expect(result[2].content).toEqual([
+      {
+        type: 'tool-result',
+        toolCallId: 'tool-call-1',
+        toolName: 'getWeather',
+        result: { location: 'San Francisco' },
+      },
+    ]);
     expect(result[3].role).toBe('assistant');
   });
 });

package/src/adapters/agui.ts

@@ -1,19 +1,19 @@
 // Cross-platform UUID generation function
-import { AbstractAgent, EventType } from '@ag-ui/client';
 import type {
+  AgentConfig,
   BaseEvent,
+  Message,
   RunAgentInput,
-  AgentConfig,
-  RunStartedEvent,
   RunFinishedEvent,
-  TextMessageStartEvent,
+  RunStartedEvent,
   TextMessageContentEvent,
   TextMessageEndEvent,
-  Message,
-  ToolCallStartEvent,
+  TextMessageStartEvent,
   ToolCallArgsEvent,
   ToolCallEndEvent,
+  ToolCallStartEvent,
 } from '@ag-ui/client';
+import { AbstractAgent, EventType } from '@ag-ui/client';
 import type { CoreMessage } from '@mastra/core';
 import { Observable } from 'rxjs';
 import type { Agent } from '../resources/agent';
@@ -39,7 +39,6 @@ export class AGUIAdapter extends AbstractAgent {
   protected run(input: RunAgentInput): Observable<BaseEvent> {
     return new Observable<BaseEvent>(subscriber => {
       const convertedMessages = convertMessagesToMastraMessages(input.messages);
-
       subscriber.next({
         type: EventType.RUN_STARTED,
         threadId: input.threadId,
@@ -66,17 +65,18 @@ export class AGUIAdapter extends AbstractAgent {
         })
         .then(response => {
           let currentMessageId: string | undefined = undefined;
+          let isInTextMessage = false;
           return response.processDataStream({
             onTextPart: text => {
               if (currentMessageId === undefined) {
                 currentMessageId = generateUUID();
-
                 const message: TextMessageStartEvent = {
                   type: EventType.TEXT_MESSAGE_START,
                   messageId: currentMessageId,
                   role: 'assistant',
                 };
                 subscriber.next(message);
+                isInTextMessage = true;
               }
 
               const message: TextMessageContentEvent = {
@@ -86,14 +86,14 @@ export class AGUIAdapter extends AbstractAgent {
               };
               subscriber.next(message);
             },
-            onFinishMessagePart: message => {
-              console.log('onFinishMessagePart', message);
+            onFinishMessagePart: () => {
               if (currentMessageId !== undefined) {
                 const message: TextMessageEndEvent = {
                   type: EventType.TEXT_MESSAGE_END,
                   messageId: currentMessageId,
                 };
                 subscriber.next(message);
+                isInTextMessage = false;
               }
               // Emit run finished event
               subscriber.next({
@@ -107,6 +107,15 @@ export class AGUIAdapter extends AbstractAgent {
             },
             onToolCallPart(streamPart) {
               const parentMessageId = currentMessageId || generateUUID();
+              if (isInTextMessage) {
+                const message: TextMessageEndEvent = {
+                  type: EventType.TEXT_MESSAGE_END,
+                  messageId: parentMessageId,
+                };
+                subscriber.next(message);
+                isInTextMessage = false;
+              }
+
               subscriber.next({
                 type: EventType.TOOL_CALL_START,
                 toolCallId: streamPart.toolCallId,
@@ -130,7 +139,7 @@ export class AGUIAdapter extends AbstractAgent {
           });
         })
         .catch(error => {
-          console.log('error', error);
+          console.error('error', error);
           // Handle error
           subscriber.error(error);
         });
@@ -195,6 +204,17 @@ export function convertMessagesToMastraMessages(messages: Message[]): CoreMessag
         role: 'assistant',
         content: parts,
       });
+      if (message.toolCalls?.length) {
+        result.push({
+          role: 'tool',
+          content: message.toolCalls.map(toolCall => ({
+            type: 'tool-result',
+            toolCallId: toolCall.id,
+            toolName: toolCall.function.name,
+            result: JSON.parse(toolCall.function.arguments),
+          })),
+        });
+      }
     } else if (message.role === 'user') {
       result.push({
         role: 'user',

package/src/client.ts

@@ -1,6 +1,18 @@
 import type { AbstractAgent } from '@ag-ui/client';
+import type { ServerDetailInfo } from '@mastra/core/mcp';
 import { AGUIAdapter } from './adapters/agui';
-import { Agent, MemoryThread, Tool, Workflow, Vector, BaseResource, Network, VNextWorkflow } from './resources';
+import {
+  Agent,
+  MemoryThread,
+  Tool,
+  Workflow,
+  Vector,
+  BaseResource,
+  Network,
+  A2A,
+  MCPTool,
+  LegacyWorkflow,
+} from './resources';
 import type {
   ClientOptions,
   CreateMemoryThreadParams,
@@ -15,10 +27,12 @@ import type {
   GetTelemetryParams,
   GetTelemetryResponse,
   GetToolResponse,
-  GetVNextWorkflowResponse,
   GetWorkflowResponse,
   SaveMessageToMemoryParams,
   SaveMessageToMemoryResponse,
+  McpServerListResponse,
+  McpServerToolListResponse,
+  GetLegacyWorkflowResponse,
 } from './types';
 
 export class MastraClient extends BaseResource {
@@ -126,6 +140,23 @@ export class MastraClient extends BaseResource {
     return new Tool(this.options, toolId);
   }
 
+  /**
+   * Retrieves all available legacy workflows
+   * @returns Promise containing map of legacy workflow IDs to legacy workflow details
+   */
+  public getLegacyWorkflows(): Promise<Record<string, GetLegacyWorkflowResponse>> {
+    return this.request('/api/workflows/legacy');
+  }
+
+  /**
+   * Gets a legacy workflow instance by ID
+   * @param workflowId - ID of the legacy workflow to retrieve
+   * @returns Legacy Workflow instance
+   */
+  public getLegacyWorkflow(workflowId: string) {
+    return new LegacyWorkflow(this.options, workflowId);
+  }
+
   /**
    * Retrieves all available workflows
    * @returns Promise containing map of workflow IDs to workflow details
@@ -143,23 +174,6 @@ export class MastraClient extends BaseResource {
     return new Workflow(this.options, workflowId);
   }
 
-  /**
-   * Retrieves all available vNext workflows
-   * @returns Promise containing map of vNext workflow IDs to vNext workflow details
-   */
-  public getVNextWorkflows(): Promise<Record<string, GetVNextWorkflowResponse>> {
-    return this.request('/api/workflows/v-next');
-  }
-
-  /**
-   * Gets a vNext workflow instance by ID
-   * @param workflowId - ID of the vNext workflow to retrieve
-   * @returns vNext Workflow instance
-   */
-  public getVNextWorkflow(workflowId: string) {
-    return new VNextWorkflow(this.options, workflowId);
-  }
-
   /**
    * Gets a vector instance by name
    * @param vectorName - Name of the vector to retrieve
@@ -175,7 +189,43 @@ export class MastraClient extends BaseResource {
    * @returns Promise containing array of log messages
    */
   public getLogs(params: GetLogsParams): Promise<GetLogsResponse> {
-    return this.request(`/api/logs?transportId=${params.transportId}`);
+    const { transportId, fromDate, toDate, logLevel, filters, page, perPage } = params;
+    const _filters = filters ? Object.entries(filters).map(([key, value]) => `${key}:${value}`) : [];
+
+    const searchParams = new URLSearchParams();
+    if (transportId) {
+      searchParams.set('transportId', transportId);
+    }
+    if (fromDate) {
+      searchParams.set('fromDate', fromDate.toISOString());
+    }
+    if (toDate) {
+      searchParams.set('toDate', toDate.toISOString());
+    }
+    if (logLevel) {
+      searchParams.set('logLevel', logLevel);
+    }
+    if (page) {
+      searchParams.set('page', String(page));
+    }
+    if (perPage) {
+      searchParams.set('perPage', String(perPage));
+    }
+    if (_filters) {
+      if (Array.isArray(_filters)) {
+        for (const filter of _filters) {
+          searchParams.append('filters', filter);
+        }
+      } else {
+        searchParams.set('filters', _filters);
+      }
+    }
+
+    if (searchParams.size) {
+      return this.request(`/api/logs?${searchParams}`);
+    } else {
+      return this.request(`/api/logs`);
+    }
   }
 
   /**
@@ -184,7 +234,47 @@ export class MastraClient extends BaseResource {
    * @returns Promise containing array of log messages
    */
   public getLogForRun(params: GetLogParams): Promise<GetLogsResponse> {
-    return this.request(`/api/logs/${params.runId}?transportId=${params.transportId}`);
+    const { runId, transportId, fromDate, toDate, logLevel, filters, page, perPage } = params;
+
+    const _filters = filters ? Object.entries(filters).map(([key, value]) => `${key}:${value}`) : [];
+    const searchParams = new URLSearchParams();
+    if (runId) {
+      searchParams.set('runId', runId);
+    }
+    if (transportId) {
+      searchParams.set('transportId', transportId);
+    }
+    if (fromDate) {
+      searchParams.set('fromDate', fromDate.toISOString());
+    }
+    if (toDate) {
+      searchParams.set('toDate', toDate.toISOString());
+    }
+    if (logLevel) {
+      searchParams.set('logLevel', logLevel);
+    }
+    if (page) {
+      searchParams.set('page', String(page));
+    }
+    if (perPage) {
+      searchParams.set('perPage', String(perPage));
+    }
+
+    if (_filters) {
+      if (Array.isArray(_filters)) {
+        for (const filter of _filters) {
+          searchParams.append('filters', filter);
+        }
+      } else {
+        searchParams.set('filters', _filters);
+      }
+    }
+
+    if (searchParams.size) {
+      return this.request(`/api/logs/${runId}?${searchParams}`);
+    } else {
+      return this.request(`/api/logs/${runId}`);
+    }
   }
 
   /**
@@ -256,4 +346,65 @@ export class MastraClient extends BaseResource {
   public getNetwork(networkId: string) {
     return new Network(this.options, networkId);
   }
+
+  /**
+   * Retrieves a list of available MCP servers.
+   * @param params - Optional parameters for pagination (limit, offset).
+   * @returns Promise containing the list of MCP servers and pagination info.
+   */
+  public getMcpServers(params?: { limit?: number; offset?: number }): Promise<McpServerListResponse> {
+    const searchParams = new URLSearchParams();
+    if (params?.limit !== undefined) {
+      searchParams.set('limit', String(params.limit));
+    }
+    if (params?.offset !== undefined) {
+      searchParams.set('offset', String(params.offset));
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/mcp/v0/servers${queryString ? `?${queryString}` : ''}`);
+  }
+
+  /**
+   * Retrieves detailed information for a specific MCP server.
+   * @param serverId - The ID of the MCP server to retrieve.
+   * @param params - Optional parameters, e.g., specific version.
+   * @returns Promise containing the detailed MCP server information.
+   */
+  public getMcpServerDetails(serverId: string, params?: { version?: string }): Promise<ServerDetailInfo> {
+    const searchParams = new URLSearchParams();
+    if (params?.version) {
+      searchParams.set('version', params.version);
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/mcp/v0/servers/${serverId}${queryString ? `?${queryString}` : ''}`);
+  }
+
+  /**
+   * Retrieves a list of tools for a specific MCP server.
+   * @param serverId - The ID of the MCP server.
+   * @returns Promise containing the list of tools.
+   */
+  public getMcpServerTools(serverId: string): Promise<McpServerToolListResponse> {
+    return this.request(`/api/mcp/${serverId}/tools`);
+  }
+
+  /**
+   * Gets an MCPTool resource instance for a specific tool on an MCP server.
+   * This instance can then be used to fetch details or execute the tool.
+   * @param serverId - The ID of the MCP server.
+   * @param toolId - The ID of the tool.
+   * @returns MCPTool instance.
+   */
+  public getMcpServerTool(serverId: string, toolId: string): MCPTool {
+    return new MCPTool(this.options, serverId, toolId);
+  }
+
+  /**
+   * Gets an A2A client for interacting with an agent via the A2A protocol
+   * @param agentId - ID of the agent to interact with
+   * @returns A2A client instance
+   */
+  public getA2A(agentId: string) {
+    return new A2A(this.options, agentId);
+  }
 }

package/src/example.ts

@@ -1,40 +1,39 @@
-// import { MastraClient } from './client';
+import { MastraClient } from './client';
 // import type { WorkflowRunResult } from './types';
 
 // Agent
 
-// (async () => {
-//   const client = new MastraClient({
-//     baseUrl: 'http://localhost:4111',
-//   });
+(async () => {
+  const client = new MastraClient({
+    baseUrl: 'http://localhost:4111',
+  });
 
-//   console.log('Starting agent...');
+  console.log('Starting agent...');
 
-//   try {
-//     const agent = client.getAgent('weatherAgent');
-//     const response = await agent.stream({
-//       messages: 'what is the weather in new york?',
-//     })
+  try {
+    const agent = client.getAgent('weatherAgent');
+    const response = await agent.stream({
+      messages: 'what is the weather in new york?',
+    });
 
-//     response.processDataStream({
-//       onTextPart: (text) => {
-//         process.stdout.write(text);
-//       },
-//       onFilePart: (file) => {
-//         console.log(file);
-//       },
-//       onDataPart: (data) => {
-//         console.log(data);
-//       },
-//       onErrorPart: (error) => {
-//         console.error(error);
-//       },
-//     });
-
-//   } catch (error) {
-//     console.error(error);
-//   }
-// })();
+    response.processDataStream({
+      onTextPart: text => {
+        process.stdout.write(text);
+      },
+      onFilePart: file => {
+        console.log(file);
+      },
+      onDataPart: data => {
+        console.log(data);
+      },
+      onErrorPart: error => {
+        console.error(error);
+      },
+    });
+  } catch (error) {
+    console.error(error);
+  }
+})();
 
 // Workflow
 // (async () => {

package/src/index.test.ts

@@ -1,6 +1,6 @@
 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();
@@ -236,6 +236,7 @@ describe('MastraClient Resources', () => {
         model: 'gpt-4',
         instructions: 'Test instructions',
         tools: {},
+        workflows: {},
       };
       mockFetchResponse(mockResponse);
 
@@ -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', () => {
@@ -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),
+          }),
+        );
+      });
+    });
+  });
 });