@mastra/client-js 0.0.0-mcp-server-deploy-20250507160341 → 0.0.0-pass-headers-for-create-mastra-client-20250529190531

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/client-js",
-  "version": "0.0.0-mcp-server-deploy-20250507160341",
+  "version": "0.0.0-pass-headers-for-create-mastra-client-20250529190531",
   "description": "The official TypeScript library for the Mastra Client API",
   "author": "",
   "type": "module",
@@ -22,14 +22,16 @@
   "repository": "github:mastra-ai/client-js",
   "license": "Elastic-2.0",
   "dependencies": {
+    "@ag-ui/client": "^0.0.27",
     "@ai-sdk/ui-utils": "^1.1.19",
     "json-schema": "^0.4.0",
-    "zod": "^3.24.2",
-    "zod-to-json-schema": "^3.24.3",
-    "@mastra/core": "0.0.0-mcp-server-deploy-20250507160341"
+    "rxjs": "7.8.1",
+    "zod": "^3.24.3",
+    "zod-to-json-schema": "^3.24.5"
   },
   "peerDependencies": {
-    "zod": "^3.24.2"
+    "zod": "^3.0.0",
+    "@mastra/core": "^0.10.0"
   },
   "devDependencies": {
     "@babel/preset-env": "^7.26.9",
@@ -40,7 +42,8 @@
     "tsup": "^8.4.0",
     "typescript": "^5.8.2",
     "vitest": "^3.1.2",
-    "@internal/lint": "0.0.2"
+    "@internal/lint": "0.0.0-pass-headers-for-create-mastra-client-20250529190531",
+    "@mastra/core": "0.0.0-pass-headers-for-create-mastra-client-20250529190531"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts --clean --treeshake=smallest --splitting",

package/src/adapters/agui.test.ts

@@ -0,0 +1,180 @@
+import type { Message } from '@ag-ui/client';
+import { describe, it, expect } from 'vitest';
+import { generateUUID, convertMessagesToMastraMessages } from './agui';
+
+describe('generateUUID', () => {
+  it('should generate a valid UUID v4 string', () => {
+    const uuid = generateUUID();
+    // Check UUID format (8-4-4-4-12 hex digits)
+    expect(uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+  });
+
+  it('should generate unique UUIDs', () => {
+    const uuids = new Set();
+    for (let i = 0; i < 100; i++) {
+      uuids.add(generateUUID());
+    }
+    // All UUIDs should be unique
+    expect(uuids.size).toBe(100);
+  });
+});
+
+describe('convertMessagesToMastraMessages', () => {
+  it('should convert user messages correctly', () => {
+    const messages: Message[] = [
+      {
+        id: '1',
+        role: 'user',
+        content: 'Hello, world!',
+      },
+    ];
+
+    const result = convertMessagesToMastraMessages(messages);
+
+    expect(result).toEqual([
+      {
+        role: 'user',
+        content: 'Hello, world!',
+      },
+    ]);
+  });
+
+  it('should convert assistant messages correctly', () => {
+    const messages: Message[] = [
+      {
+        id: '1',
+        role: 'assistant',
+        content: 'Hello, I am an assistant',
+      },
+    ];
+
+    const result = convertMessagesToMastraMessages(messages);
+
+    expect(result).toEqual([
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'Hello, I am an assistant' }],
+      },
+    ]);
+  });
+
+  it('should convert assistant messages with tool calls correctly', () => {
+    const messages: Message[] = [
+      {
+        id: '1',
+        role: 'assistant',
+        content: undefined,
+        toolCalls: [
+          {
+            id: 'tool-call-1',
+            type: 'function',
+            function: {
+              name: 'getWeather',
+              arguments: '{"location":"San Francisco"}',
+            },
+          },
+        ],
+      },
+    ];
+
+    const result = convertMessagesToMastraMessages(messages);
+
+    expect(result).toEqual([
+      {
+        role: 'assistant',
+        content: [
+          {
+            type: 'tool-call',
+            toolCallId: 'tool-call-1',
+            toolName: 'getWeather',
+            args: { location: 'San Francisco' },
+          },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: 'tool-call-1',
+            toolName: 'getWeather',
+            result: { location: 'San Francisco' },
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('should convert tool messages correctly', () => {
+    const messages: Message[] = [
+      {
+        id: '1',
+        role: 'tool',
+        toolCallId: 'tool-call-1',
+        content: '{"temperature":72,"unit":"F"}',
+      },
+    ];
+
+    const result = convertMessagesToMastraMessages(messages);
+
+    expect(result).toEqual([
+      {
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: 'tool-call-1',
+            toolName: 'unknown',
+            result: '{"temperature":72,"unit":"F"}',
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('should convert a complex conversation correctly', () => {
+    const messages: Message[] = [
+      {
+        id: '1',
+        role: 'user',
+        content: "What's the weather in San Francisco?",
+      },
+      {
+        id: '2',
+        role: 'assistant',
+        content: undefined,
+        toolCalls: [
+          {
+            id: 'tool-call-1',
+            type: 'function',
+            function: {
+              name: 'getWeather',
+              arguments: '{"location":"San Francisco"}',
+            },
+          },
+        ],
+      },
+      {
+        id: '4',
+        role: 'assistant',
+        content: 'The weather in San Francisco is 72°F.',
+      },
+    ];
+
+    const result = convertMessagesToMastraMessages(messages);
+
+    expect(result).toHaveLength(4);
+    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

@@ -0,0 +1,239 @@
+// Cross-platform UUID generation function
+import type {
+  AgentConfig,
+  BaseEvent,
+  Message,
+  RunAgentInput,
+  RunFinishedEvent,
+  RunStartedEvent,
+  TextMessageContentEvent,
+  TextMessageEndEvent,
+  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';
+
+interface MastraAgentConfig extends AgentConfig {
+  agent: Agent;
+  agentId: string;
+  resourceId?: string;
+}
+
+export class AGUIAdapter extends AbstractAgent {
+  agent: Agent;
+  resourceId?: string;
+  constructor({ agent, agentId, resourceId, ...rest }: MastraAgentConfig) {
+    super({
+      agentId,
+      ...rest,
+    });
+    this.agent = agent;
+    this.resourceId = resourceId;
+  }
+
+  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,
+        runId: input.runId,
+      } as RunStartedEvent);
+
+      this.agent
+        .stream({
+          threadId: input.threadId,
+          resourceId: this.resourceId ?? '',
+          runId: input.runId,
+          messages: convertedMessages,
+          clientTools: input.tools.reduce(
+            (acc, tool) => {
+              acc[tool.name as string] = {
+                id: tool.name,
+                description: tool.description,
+                inputSchema: tool.parameters,
+              };
+              return acc;
+            },
+            {} as Record<string, any>,
+          ),
+        })
+        .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 = {
+                type: EventType.TEXT_MESSAGE_CONTENT,
+                messageId: currentMessageId,
+                delta: text,
+              };
+              subscriber.next(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({
+                type: EventType.RUN_FINISHED,
+                threadId: input.threadId,
+                runId: input.runId,
+              } as RunFinishedEvent);
+
+              // Complete the observable
+              subscriber.complete();
+            },
+            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,
+                toolCallName: streamPart.toolName,
+                parentMessageId,
+              } as ToolCallStartEvent);
+
+              subscriber.next({
+                type: EventType.TOOL_CALL_ARGS,
+                toolCallId: streamPart.toolCallId,
+                delta: JSON.stringify(streamPart.args),
+                parentMessageId,
+              } as ToolCallArgsEvent);
+
+              subscriber.next({
+                type: EventType.TOOL_CALL_END,
+                toolCallId: streamPart.toolCallId,
+                parentMessageId,
+              } as ToolCallEndEvent);
+            },
+          });
+        })
+        .catch(error => {
+          console.error('error', error);
+          // Handle error
+          subscriber.error(error);
+        });
+
+      return () => {};
+    });
+  }
+}
+
+/**
+ * Generates a UUID v4 that works in both browser and Node.js environments
+ */
+export function generateUUID(): string {
+  // Use crypto.randomUUID() if available (Node.js environment or modern browsers)
+  if (typeof crypto !== 'undefined') {
+    // Browser crypto API or Node.js crypto global
+    if (typeof crypto.randomUUID === 'function') {
+      return crypto.randomUUID();
+    }
+    // Fallback for older browsers
+    if (typeof crypto.getRandomValues === 'function') {
+      const buffer = new Uint8Array(16);
+      crypto.getRandomValues(buffer);
+      // Set version (4) and variant (8, 9, A, or B)
+      buffer[6] = (buffer[6]! & 0x0f) | 0x40; // version 4
+      buffer[8] = (buffer[8]! & 0x3f) | 0x80; // variant
+
+      // Convert to hex string in UUID format
+      let hex = '';
+      for (let i = 0; i < 16; i++) {
+        hex += buffer[i]!.toString(16).padStart(2, '0');
+        // Add hyphens at standard positions
+        if (i === 3 || i === 5 || i === 7 || i === 9) hex += '-';
+      }
+      return hex;
+    }
+  }
+
+  // Last resort fallback (less secure but works everywhere)
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
+export function convertMessagesToMastraMessages(messages: Message[]): CoreMessage[] {
+  const result: CoreMessage[] = [];
+
+  for (const message of messages) {
+    if (message.role === 'assistant') {
+      const parts: any[] = message.content ? [{ type: 'text', text: message.content }] : [];
+      for (const toolCall of message.toolCalls ?? []) {
+        parts.push({
+          type: 'tool-call',
+          toolCallId: toolCall.id,
+          toolName: toolCall.function.name,
+          args: JSON.parse(toolCall.function.arguments),
+        });
+      }
+      result.push({
+        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',
+        content: message.content || '',
+      });
+    } else if (message.role === 'tool') {
+      result.push({
+        role: 'tool',
+        content: [
+          {
+            type: 'tool-result',
+            toolCallId: message.toolCallId,
+            toolName: 'unknown',
+            result: message.content,
+          },
+        ],
+      });
+    }
+  }
+
+  return result;
+}

package/src/client.ts

@@ -1,3 +1,6 @@
+import type { AbstractAgent } from '@ag-ui/client';
+import type { ServerDetailInfo } from '@mastra/core/mcp';
+import { AGUIAdapter } from './adapters/agui';
 import {
   Agent,
   MemoryThread,
@@ -6,8 +9,9 @@ import {
   Vector,
   BaseResource,
   Network,
-  VNextWorkflow,
-  MCPServer,
+  A2A,
+  MCPTool,
+  LegacyWorkflow,
 } from './resources';
 import type {
   ClientOptions,
@@ -17,17 +21,18 @@ import type {
   GetLogParams,
   GetLogsParams,
   GetLogsResponse,
-  GetMCPServerResponse,
   GetMemoryThreadParams,
   GetMemoryThreadResponse,
   GetNetworkResponse,
   GetTelemetryParams,
   GetTelemetryResponse,
   GetToolResponse,
-  GetVNextWorkflowResponse,
   GetWorkflowResponse,
   SaveMessageToMemoryParams,
   SaveMessageToMemoryResponse,
+  McpServerListResponse,
+  McpServerToolListResponse,
+  GetLegacyWorkflowResponse,
 } from './types';
 
 export class MastraClient extends BaseResource {
@@ -43,6 +48,25 @@ export class MastraClient extends BaseResource {
     return this.request('/api/agents');
   }
 
+  public async getAGUI({ resourceId }: { resourceId: string }): Promise<Record<string, AbstractAgent>> {
+    const agents = await this.getAgents();
+
+    return Object.entries(agents).reduce(
+      (acc, [agentId]) => {
+        const agent = this.getAgent(agentId);
+
+        acc[agentId] = new AGUIAdapter({
+          agentId,
+          agent,
+          resourceId,
+        });
+
+        return acc;
+      },
+      {} as Record<string, AbstractAgent>,
+    );
+  }
+
   /**
    * Gets an agent instance by ID
    * @param agentId - ID of the agent to retrieve
@@ -116,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
@@ -133,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
@@ -248,19 +272,63 @@ export class MastraClient extends BaseResource {
   }
 
   /**
-   * Retrieves all available MCP servers
-   * @returns Promise containing map of MCP server IDs to server details
+   * 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 getMCPServers(): Promise<Record<string, GetMCPServerResponse>> {
-    return this.request('/api/mcp/servers');
+  public getMcpServerTool(serverId: string, toolId: string): MCPTool {
+    return new MCPTool(this.options, serverId, toolId);
   }
 
   /**
-   * Gets an MCP server instance by ID
-   * @param serverId - ID of the MCP server to retrieve
-   * @returns MCPServer instance
+   * 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 getMCPServer(serverId: string) {
-    return new MCPServer(this.options, serverId);
+  public getA2A(agentId: string) {
+    return new A2A(this.options, agentId);
   }
 }