@mastra/client-js 0.0.0-mastra-3123-mcp-server-20250419180157 → 0.0.0-mastra-3338-mastra-memory-pinecone-20250507174328

package/src/adapters/agui.ts

@@ -0,0 +1,219 @@
+// Cross-platform UUID generation function
+import { AbstractAgent, EventType } from '@ag-ui/client';
+import type {
+  BaseEvent,
+  RunAgentInput,
+  AgentConfig,
+  RunStartedEvent,
+  RunFinishedEvent,
+  TextMessageStartEvent,
+  TextMessageContentEvent,
+  TextMessageEndEvent,
+  Message,
+  ToolCallStartEvent,
+  ToolCallArgsEvent,
+  ToolCallEndEvent,
+} 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;
+          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);
+              }
+
+              const message: TextMessageContentEvent = {
+                type: EventType.TEXT_MESSAGE_CONTENT,
+                messageId: currentMessageId,
+                delta: text,
+              };
+              subscriber.next(message);
+            },
+            onFinishMessagePart: message => {
+              console.log('onFinishMessagePart', message);
+              if (currentMessageId !== undefined) {
+                const message: TextMessageEndEvent = {
+                  type: EventType.TEXT_MESSAGE_END,
+                  messageId: currentMessageId,
+                };
+                subscriber.next(message);
+              }
+              // 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();
+              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.log('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,
+      });
+    } 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,4 +1,6 @@
-import { Agent, MemoryThread, Tool, Workflow, Vector, BaseResource, Network } from './resources';
+import type { AbstractAgent } from '@ag-ui/client';
+import { AGUIAdapter } from './adapters/agui';
+import { Agent, MemoryThread, Tool, Workflow, Vector, BaseResource, Network, VNextWorkflow } from './resources';
 import type {
   ClientOptions,
   CreateMemoryThreadParams,
@@ -13,8 +15,8 @@ import type {
   GetTelemetryParams,
   GetTelemetryResponse,
   GetToolResponse,
+  GetVNextWorkflowResponse,
   GetWorkflowResponse,
-  RequestOptions,
   SaveMessageToMemoryParams,
   SaveMessageToMemoryResponse,
 } from './types';
@@ -32,6 +34,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
@@ -122,6 +143,23 @@ 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
@@ -163,17 +201,9 @@ export class MastraClient extends BaseResource {
    * @returns Promise containing telemetry data
    */
   public getTelemetry(params?: GetTelemetryParams): Promise<GetTelemetryResponse> {
-    const { name, scope, page, perPage, attribute } = params || {};
+    const { name, scope, page, perPage, attribute, fromDate, toDate } = params || {};
     const _attribute = attribute ? Object.entries(attribute).map(([key, value]) => `${key}:${value}`) : [];
 
-    const queryObj = {
-      ...(name ? { name } : {}),
-      ...(scope ? { scope } : {}),
-      ...(page ? { page: String(page) } : {}),
-      ...(perPage ? { perPage: String(perPage) } : {}),
-      ...(_attribute?.length ? { attribute: _attribute } : {}),
-    } as const;
-
     const searchParams = new URLSearchParams();
     if (name) {
       searchParams.set('name', name);
@@ -196,6 +226,12 @@ export class MastraClient extends BaseResource {
         searchParams.set('attribute', _attribute);
       }
     }
+    if (fromDate) {
+      searchParams.set('fromDate', fromDate.toISOString());
+    }
+    if (toDate) {
+      searchParams.set('toDate', toDate.toISOString());
+    }
 
     if (searchParams.size) {
       return this.request(`/api/telemetry?${searchParams}`);

package/src/index.test.ts

@@ -1,4 +1,3 @@
-import type { MessageType } from '@mastra/core';
 import { describe, expect, beforeEach, it, vi } from 'vitest';
 
 import { MastraClient } from './client';
@@ -489,7 +488,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 +535,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'),
         },
       ];
@@ -584,10 +584,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({

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 type {
   GenerateParams,
@@ -29,7 +29,6 @@ export class AgentTool extends BaseResource {
    * @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',
@@ -127,6 +126,7 @@ export class Agent extends BaseResource {
         params.experimental_output instanceof ZodSchema
           ? zodToJsonSchema(params.experimental_output)
           : params.experimental_output,
+      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : undefined,
     };
 
     return this.request(`/api/agents/${this.agentId}/generate`, {
@@ -154,6 +154,7 @@ export class Agent extends BaseResource {
         params.experimental_output instanceof ZodSchema
           ? zodToJsonSchema(params.experimental_output)
           : params.experimental_output,
+      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : undefined,
     };
 
     const response: Response & {

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;

package/src/resources/index.ts

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

package/src/resources/memory-thread.ts

@@ -1,13 +1,6 @@
 import type { StorageThreadType } from '@mastra/core';
 
-import type {
-  CreateMemoryThreadParams,
-  GetMemoryThreadMessagesResponse,
-  GetMemoryThreadResponse,
-  ClientOptions,
-  SaveMessageToMemoryParams,
-  UpdateMemoryThreadParams,
-} from '../types';
+import type { GetMemoryThreadMessagesResponse, ClientOptions, UpdateMemoryThreadParams } from '../types';
 
 import { BaseResource } from './base';
 

package/src/resources/network.ts

@@ -1,3 +1,4 @@
+import { processDataStream } from '@ai-sdk/ui-utils';
 import type { GenerateReturn } from '@mastra/core';
 import type { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
@@ -6,7 +7,6 @@ import { zodToJsonSchema } from '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(

package/src/resources/tool.ts

@@ -23,10 +23,16 @@ 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 }): Promise<any> {
+    const url = new URLSearchParams();
+
+    if (params.runId) {
+      url.set('runId', params.runId);
+    }
+
+    return this.request(`/api/tools/${this.toolId}/execute?${url.toString()}`, {
       method: 'POST',
-      body: params,
+      body: params.data,
     });
   }
 }