@mastra/client-js 0.0.0-storage-20250225005900 → 0.0.0-taofeeqInngest-20250603090617

package/src/resources/agent.ts

@@ -1,7 +1,8 @@
-import type { GenerateReturn, StreamReturn } from '@mastra/core';
+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,
@@ -13,35 +14,81 @@ import type {
 } from '../types';
 
 import { BaseResource } from './base';
+import type { RuntimeContext } from '@mastra/core/runtime-context';
+import { parseClientRuntimeContext } from '../utils';
 
-export class AgentTool extends BaseResource {
+export class AgentVoice extends BaseResource {
   constructor(
     options: ClientOptions,
     private agentId: string,
-    private toolId: string,
   ) {
     super(options);
+    this.agentId = agentId;
   }
 
   /**
-   * Executes a specific tool for an agent
-   * @param params - Parameters required for tool execution
-   * @returns Promise containing tool execution results
+   * Convert text to speech using the agent's voice provider
+   * @param text - Text to convert to speech
+   * @param options - Optional provider-specific options for speech generation
+   * @returns Promise containing the audio data
+   */
+  async speak(text: string, options?: { speaker?: string; [key: string]: any }): Promise<Response> {
+    return this.request<Response>(`/api/agents/${this.agentId}/voice/speak`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: { input: text, options },
+      stream: true,
+    });
+  }
+
+  /**
+   * Convert speech to text using the agent's voice provider
+   * @param audio - Audio data to transcribe
+   * @param options - Optional provider-specific options
+   * @returns Promise containing the transcribed text
    */
-  execute(params: { data: any }): Promise<any> {
-    return this.request(`/api/agents/${this.agentId}/tools/${this.toolId}/execute`, {
+  listen(audio: Blob, options?: Record<string, any>): Promise<{ text: string }> {
+    const formData = new FormData();
+    formData.append('audio', audio);
+
+    if (options) {
+      formData.append('options', JSON.stringify(options));
+    }
+
+    return this.request(`/api/agents/${this.agentId}/voice/listen`, {
       method: 'POST',
-      body: params,
+      body: formData,
     });
   }
+
+  /**
+   * Get available speakers for the agent's voice provider
+   * @returns Promise containing list of available speakers
+   */
+  getSpeakers(): Promise<Array<{ voiceId: string; [key: string]: any }>> {
+    return this.request(`/api/agents/${this.agentId}/voice/speakers`);
+  }
+
+  /**
+   * Get the listener configuration for the agent's voice provider
+   * @returns Promise containing a check if the agent has listening capabilities
+   */
+  getListener(): Promise<{ enabled: boolean }> {
+    return this.request(`/api/agents/${this.agentId}/voice/listener`);
+  }
 }
 
 export class Agent extends BaseResource {
+  public readonly voice: AgentVoice;
+
   constructor(
     options: ClientOptions,
     private agentId: string,
   ) {
     super(options);
+    this.voice = new AgentVoice(options, this.agentId);
   }
 
   /**
@@ -62,7 +109,9 @@ export class Agent extends BaseResource {
   ): Promise<GenerateReturn<T>> {
     const processedParams = {
       ...params,
-      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
+      output: params.output ? zodToJsonSchema(params.output) : undefined,
+      experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : undefined,
+      runtimeContext: parseClientRuntimeContext(params.runtimeContext),
     };
 
     return this.request(`/api/agents/${this.agentId}/generate`, {
@@ -74,19 +123,42 @@ export class Agent extends BaseResource {
   /**
    * Streams a response from the agent
    * @param params - Stream parameters including prompt
-   * @returns Promise containing the streamed response
+   * @returns Promise containing the enhanced Response object with processDataStream method
    */
-  stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: StreamParams<T>): Promise<Response> {
+  async stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(
+    params: StreamParams<T>,
+  ): Promise<
+    Response & {
+      processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
+    }
+  > {
     const processedParams = {
       ...params,
-      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
+      output: params.output ? zodToJsonSchema(params.output) : undefined,
+      experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : undefined,
+      runtimeContext: parseClientRuntimeContext(params.runtimeContext),
     };
 
-    return this.request(`/api/agents/${this.agentId}/stream`, {
+    const response: Response & {
+      processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
+    } = await this.request(`/api/agents/${this.agentId}/stream`, {
       method: 'POST',
       body: processedParams,
       stream: true,
     });
+
+    if (!response.body) {
+      throw new Error('No response body');
+    }
+
+    response.processDataStream = async (options = {}) => {
+      await processDataStream({
+        stream: response.body as ReadableStream<Uint8Array>,
+        ...options,
+      });
+    };
+
+    return response;
   }
 
   /**
@@ -98,6 +170,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,14 +21,16 @@ 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: {
-            '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',
           },
-          body: options.body ? JSON.stringify(options.body) : undefined,
+          body:
+            options.body instanceof FormData ? options.body : options.body ? JSON.stringify(options.body) : undefined,
         });
 
         if (!response.ok) {

package/src/resources/index.ts

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

package/src/resources/legacy-workflow.ts

@@ -0,0 +1,242 @@
+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

@@ -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,12 +1,10 @@
 import type { StorageThreadType } from '@mastra/core';
 
 import type {
-  CreateMemoryThreadParams,
   GetMemoryThreadMessagesResponse,
-  GetMemoryThreadResponse,
   ClientOptions,
-  SaveMessageToMemoryParams,
   UpdateMemoryThreadParams,
+  GetMemoryThreadMessagesParams,
 } from '../types';
 
 import { BaseResource } from './base';
@@ -52,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

@@ -0,0 +1,86 @@
+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 '../utils/zod-to-json-schema';
+
+import type { GenerateParams, ClientOptions, StreamParams, GetNetworkResponse } from '../types';
+
+import { BaseResource } from './base';
+
+export class Network extends BaseResource {
+  constructor(
+    options: ClientOptions,
+    private networkId: string,
+  ) {
+    super(options);
+  }
+
+  /**
+   * Retrieves details about the network
+   * @returns Promise containing network details
+   */
+  details(): Promise<GetNetworkResponse> {
+    return this.request(`/api/networks/${this.networkId}`);
+  }
+
+  /**
+   * Generates a response from the agent
+   * @param params - Generation parameters including prompt
+   * @returns Promise containing the generated response
+   */
+  generate<T extends JSONSchema7 | ZodSchema | undefined = undefined>(
+    params: GenerateParams<T>,
+  ): Promise<GenerateReturn<T>> {
+    const processedParams = {
+      ...params,
+      output: zodToJsonSchema(params.output),
+      experimental_output: zodToJsonSchema(params.experimental_output),
+    };
+
+    return this.request(`/api/networks/${this.networkId}/generate`, {
+      method: 'POST',
+      body: processedParams,
+    });
+  }
+
+  /**
+   * Streams a response from the agent
+   * @param params - Stream parameters including prompt
+   * @returns Promise containing the enhanced Response object with processDataStream method
+   */
+  async stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(
+    params: StreamParams<T>,
+  ): Promise<
+    Response & {
+      processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
+    }
+  > {
+    const processedParams = {
+      ...params,
+      output: zodToJsonSchema(params.output),
+      experimental_output: zodToJsonSchema(params.experimental_output),
+    };
+
+    const response: Response & {
+      processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
+    } = await this.request(`/api/networks/${this.networkId}/stream`, {
+      method: 'POST',
+      body: processedParams,
+      stream: true,
+    });
+
+    if (!response.body) {
+      throw new Error('No response body');
+    }
+
+    response.processDataStream = async (options = {}) => {
+      await processDataStream({
+        stream: response.body as ReadableStream<Uint8Array>,
+        ...options,
+      });
+    };
+
+    return response;
+  }
+}

package/src/resources/tool.ts

@@ -1,6 +1,8 @@
+import type { RuntimeContext } from '@mastra/core/runtime-context';
 import type { GetToolResponse, ClientOptions } from '../types';
 
 import { BaseResource } from './base';
+import { parseClientRuntimeContext } from '../utils';
 
 export class Tool extends BaseResource {
   constructor(
@@ -23,10 +25,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 | Record<string, any> }): Promise<any> {
+    const url = new URLSearchParams();
+
+    if (params.runId) {
+      url.set('runId', params.runId);
+    }
+
+    const body = {
+      data: params.data,
+      runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+    };
+
+    return this.request(`/api/tools/${this.toolId}/execute?${url.toString()}`, {
       method: 'POST',
-      body: params,
+      body,
     });
   }
 }