@mastra/client-js 0.0.0-commonjs-20250227130920 → 0.0.0-default-storage-virtual-file-20250410035748

package/dist/index.cjs

@@ -2,6 +2,7 @@
 
 var zod = require('zod');
 var zodToJsonSchema = require('zod-to-json-schema');
+var uiUtils = require('@ai-sdk/ui-utils');
 
 // src/resources/agent.ts
 
@@ -26,11 +27,12 @@ var BaseResource = class {
         const response = await fetch(`${baseUrl}${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) : void 0
+          body: options.body instanceof FormData ? options.body : options.body ? JSON.stringify(options.body) : void 0
         });
         if (!response.ok) {
           const errorBody = await response.text();
@@ -64,11 +66,60 @@ var BaseResource = class {
 };
 
 // src/resources/agent.ts
+var AgentVoice = class extends BaseResource {
+  constructor(options, agentId) {
+    super(options);
+    this.agentId = agentId;
+    this.agentId = agentId;
+  }
+  /**
+   * 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, options) {
+    return this.request(`/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
+   */
+  listen(audio, options) {
+    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: formData
+    });
+  }
+  /**
+   * Get available speakers for the agent's voice provider
+   * @returns Promise containing list of available speakers
+   */
+  getSpeakers() {
+    return this.request(`/api/agents/${this.agentId}/voice/speakers`);
+  }
+};
 var Agent = class extends BaseResource {
   constructor(options, agentId) {
     super(options);
     this.agentId = agentId;
+    this.voice = new AgentVoice(options, this.agentId);
   }
+  voice;
   /**
    * Retrieves details about the agent
    * @returns Promise containing agent details including model and instructions
@@ -84,7 +135,8 @@ var Agent = class extends BaseResource {
   generate(params) {
     const processedParams = {
       ...params,
-      output: params.output instanceof zod.ZodSchema ? zodToJsonSchema.zodToJsonSchema(params.output) : params.output
+      output: params.output instanceof zod.ZodSchema ? zodToJsonSchema.zodToJsonSchema(params.output) : params.output,
+      experimental_output: params.experimental_output instanceof zod.ZodSchema ? zodToJsonSchema.zodToJsonSchema(params.experimental_output) : params.experimental_output
     };
     return this.request(`/api/agents/${this.agentId}/generate`, {
       method: "POST",
@@ -94,18 +146,29 @@ var Agent = class 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(params) {
+  async stream(params) {
     const processedParams = {
       ...params,
-      output: params.output instanceof zod.ZodSchema ? zodToJsonSchema.zodToJsonSchema(params.output) : params.output
+      output: params.output instanceof zod.ZodSchema ? zodToJsonSchema.zodToJsonSchema(params.output) : params.output,
+      experimental_output: params.experimental_output instanceof zod.ZodSchema ? zodToJsonSchema.zodToJsonSchema(params.experimental_output) : params.experimental_output
     };
-    return this.request(`/api/agents/${this.agentId}/stream`, {
+    const response = 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 uiUtils.processDataStream({
+        stream: response.body,
+        ...options
+      });
+    };
+    return response;
   }
   /**
    * Gets details about a specific tool available to the agent
@@ -130,6 +193,62 @@ var Agent = class extends BaseResource {
     return this.request(`/api/agents/${this.agentId}/evals/live`);
   }
 };
+var Network = class extends BaseResource {
+  constructor(options, networkId) {
+    super(options);
+    this.networkId = networkId;
+  }
+  /**
+   * Retrieves details about the network
+   * @returns Promise containing network details
+   */
+  details() {
+    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(params) {
+    const processedParams = {
+      ...params,
+      output: params.output instanceof zod.ZodSchema ? zodToJsonSchema.zodToJsonSchema(params.output) : params.output,
+      experimental_output: params.experimental_output instanceof zod.ZodSchema ? zodToJsonSchema.zodToJsonSchema(params.experimental_output) : 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(params) {
+    const processedParams = {
+      ...params,
+      output: params.output instanceof zod.ZodSchema ? zodToJsonSchema.zodToJsonSchema(params.output) : params.output,
+      experimental_output: params.experimental_output instanceof zod.ZodSchema ? zodToJsonSchema.zodToJsonSchema(params.experimental_output) : params.experimental_output
+    };
+    const response = 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 uiUtils.processDataStream({
+        stream: response.body,
+        ...options
+      });
+    };
+    return response;
+  }
+};
 
 // src/resources/memory-thread.ts
 var MemoryThread = class extends BaseResource {
@@ -241,6 +360,7 @@ var Vector = class extends BaseResource {
 };
 
 // src/resources/workflow.ts
+var RECORD_SEPARATOR = "";
 var Workflow = class extends BaseResource {
   constructor(options, workflowId) {
     super(options);
@@ -254,6 +374,7 @@ var Workflow = class extends BaseResource {
     return this.request(`/api/workflows/${this.workflowId}`);
   }
   /**
+   * @deprecated Use `startAsync` instead
    * Executes the workflow with the provided parameters
    * @param params - Parameters required for workflow execution
    * @returns Promise containing the workflow execution results
@@ -265,7 +386,31 @@ var Workflow = class extends BaseResource {
     });
   }
   /**
-   * Resumes a suspended workflow step
+   * Creates a new workflow run
+   * @returns Promise containing the generated run ID
+   */
+  createRun(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    return this.request(`/api/workflows/${this.workflowId}/createRun?${searchParams.toString()}`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Starts a 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) {
+    return this.request(`/api/workflows/${this.workflowId}/start?runId=${params.runId}`, {
+      method: "POST",
+      body: params?.triggerData
+    });
+  }
+  /**
+   * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
    * @param stepId - ID of the step to resume
    * @param runId - ID of the workflow run
    * @param context - Context to resume the workflow with
@@ -276,23 +421,106 @@ var Workflow = class extends BaseResource {
     runId,
     context
   }) {
-    return this.request(`/api/workflows/${this.workflowId}/resume`, {
+    return this.request(`/api/workflows/${this.workflowId}/resume?runId=${runId}`, {
       method: "POST",
       body: {
         stepId,
-        runId,
         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) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
+      method: "POST",
+      body: params?.triggerData
+    });
+  }
+  /**
+   * Resumes a suspended 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) {
+    return this.request(`/api/workflows/${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
+   */
+  async *streamProcessor(stream) {
+    const reader = stream.getReader();
+    let doneReading = false;
+    let buffer = "";
+    try {
+      while (!doneReading) {
+        const { done, value } = await reader.read();
+        doneReading = done;
+        if (done && !value) continue;
+        try {
+          const decoded = value ? new TextDecoder().decode(value) : "";
+          const chunks = (buffer + decoded).split(RECORD_SEPARATOR);
+          buffer = chunks.pop() || "";
+          for (const chunk of chunks) {
+            if (chunk) {
+              if (typeof chunk === "string") {
+                try {
+                  const parsedChunk = JSON.parse(chunk);
+                  yield parsedChunk;
+                } catch {
+                }
+              }
+            }
+          }
+        } catch (error) {
+        }
+      }
+      if (buffer) {
+        try {
+          yield JSON.parse(buffer);
+        } catch {
+        }
+      }
+    } finally {
+      reader.cancel().catch(() => {
+      });
+    }
+  }
   /**
    * Watches workflow transitions in real-time
-   * @returns Promise containing the workflow watch stream
+   * @param runId - Optional run ID to filter the watch stream
+   * @returns AsyncGenerator that yields parsed records from the workflow watch stream
    */
-  watch() {
-    return this.request(`/api/workflows/${this.workflowId}/watch`, {
+  async watch({ runId }, onRecord) {
+    const response = await this.request(`/api/workflows/${this.workflowId}/watch?runId=${runId}`, {
       stream: true
     });
+    if (!response.ok) {
+      throw new Error(`Failed to watch workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    for await (const record of this.streamProcessor(response.body)) {
+      onRecord(record);
+    }
   }
 };
 
@@ -453,9 +681,6 @@ var MastraClient = class extends BaseResource {
   getTelemetry(params) {
     const { name, scope, page, perPage, attribute } = params || {};
     const _attribute = attribute ? Object.entries(attribute).map(([key, value]) => `${key}:${value}`) : [];
-    ({
-      ..._attribute?.length ? { attribute: _attribute } : {}
-    });
     const searchParams = new URLSearchParams();
     if (name) {
       searchParams.set("name", name);
@@ -484,6 +709,21 @@ var MastraClient = class extends BaseResource {
       return this.request(`/api/telemetry`);
     }
   }
+  /**
+   * Retrieves all available networks
+   * @returns Promise containing map of network IDs to network details
+   */
+  getNetworks() {
+    return this.request("/api/networks");
+  }
+  /**
+   * Gets a network instance by ID
+   * @param networkId - ID of the network to retrieve
+   * @returns Network instance
+   */
+  getNetwork(networkId) {
+    return new Network(this.options, networkId);
+  }
 };
 
 exports.MastraClient = MastraClient;

package/dist/index.d.cts

@@ -1,6 +1,8 @@
-import { CoreMessage, OutputType, StorageThreadType, AiMessageType, MessageType, StepAction, StepGraph, QueryResult, BaseLogMessage, GenerateReturn } from '@mastra/core';
+import { CoreMessage, AiMessageType, StorageThreadType, MessageType, StepAction, StepGraph, WorkflowRunResult as WorkflowRunResult$1, QueryResult, BaseLogMessage, GenerateReturn } from '@mastra/core';
 import { JSONSchema7 } from 'json-schema';
 import { ZodSchema } from 'zod';
+import { processDataStream } from '@ai-sdk/ui-utils';
+import { AgentGenerateOptions, AgentStreamOptions } from '@mastra/core/agent';
 
 interface ClientOptions {
     /** Base URL for API requests */
@@ -19,25 +21,21 @@ interface RequestOptions {
     headers?: Record<string, string>;
     body?: any;
     stream?: boolean;
+    signal?: AbortSignal;
 }
 interface GetAgentResponse {
     name: string;
     instructions: string;
     tools: Record<string, GetToolResponse>;
     provider: string;
+    modelId: string;
 }
-interface GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
-    messages: string | string[] | CoreMessage[];
-    threadId?: string;
-    resourceid?: string;
-    output?: OutputType | T;
-}
-interface StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
-    messages: string | string[] | CoreMessage[];
-    threadId?: string;
-    resourceid?: string;
-    output?: OutputType | T;
-}
+type GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
+    messages: string | string[] | CoreMessage[] | AiMessageType[];
+} & Partial<AgentGenerateOptions<T>>;
+type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
+    messages: string | string[] | CoreMessage[] | AiMessageType[];
+} & Omit<AgentStreamOptions<T>, 'onFinish' | 'onStepFinish' | 'telemetry'>;
 interface GetEvalsByAgentIdResponse extends GetAgentResponse {
     evals: any[];
 }
@@ -53,7 +51,18 @@ interface GetWorkflowResponse {
     steps: Record<string, StepAction<any, any, any, any>>;
     stepGraph: StepGraph;
     stepSubscriberGraph: Record<string, StepGraph>;
+    workflowId?: string;
 }
+type WorkflowRunResult = {
+    activePaths: Record<string, {
+        status: string;
+        suspendPayload?: any;
+        stepPath: string[];
+    }>;
+    results: WorkflowRunResult$1<any, any, any>['results'];
+    timestamp: number;
+    runId: string;
+};
 interface UpsertVectorParams {
     indexName: string;
     vectors: number[][];
@@ -116,8 +125,47 @@ interface GetLogParams {
 }
 type GetLogsResponse = BaseLogMessage[];
 type RequestFunction = (path: string, options?: RequestOptions) => Promise<any>;
+type SpanStatus = {
+    code: number;
+};
+type SpanOther = {
+    droppedAttributesCount: number;
+    droppedEventsCount: number;
+    droppedLinksCount: number;
+};
+type SpanEventAttributes = {
+    key: string;
+    value: {
+        [key: string]: string | number | boolean | null;
+    };
+};
+type SpanEvent = {
+    attributes: SpanEventAttributes[];
+    name: string;
+    timeUnixNano: string;
+    droppedAttributesCount: number;
+};
+type Span = {
+    id: string;
+    parentSpanId: string | null;
+    traceId: string;
+    name: string;
+    scope: string;
+    kind: number;
+    status: SpanStatus;
+    events: SpanEvent[];
+    links: any[];
+    attributes: Record<string, string | number | boolean | null>;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    other: SpanOther;
+    createdAt: string;
+};
 interface GetTelemetryResponse {
-    traces: any[];
+    traces: {
+        traces: Span[];
+    };
 }
 interface GetTelemetryParams {
     name?: string;
@@ -126,6 +174,20 @@ interface GetTelemetryParams {
     perPage?: number;
     attribute?: Record<string, string>;
 }
+interface GetNetworkResponse {
+    name: string;
+    instructions: string;
+    agents: Array<{
+        name: string;
+        provider: string;
+        modelId: string;
+    }>;
+    routingModel: {
+        provider: string;
+        modelId: string;
+    };
+    state?: Record<string, any>;
+}
 
 declare class BaseResource {
     readonly options: ClientOptions;
@@ -139,8 +201,38 @@ declare class BaseResource {
     request<T>(path: string, options?: RequestOptions): Promise<T>;
 }
 
+declare class AgentVoice extends BaseResource {
+    private agentId;
+    constructor(options: ClientOptions, agentId: string);
+    /**
+     * 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
+     */
+    speak(text: string, options?: {
+        speaker?: string;
+        [key: string]: any;
+    }): Promise<Response>;
+    /**
+     * 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
+     */
+    listen(audio: Blob, options?: Record<string, any>): Promise<Response>;
+    /**
+     * Get available speakers for the agent's voice provider
+     * @returns Promise containing list of available speakers
+     */
+    getSpeakers(): Promise<Array<{
+        voiceId: string;
+        [key: string]: any;
+    }>>;
+}
 declare class Agent extends BaseResource {
     private agentId;
+    readonly voice: AgentVoice;
     constructor(options: ClientOptions, agentId: string);
     /**
      * Retrieves details about the agent
@@ -156,9 +248,11 @@ declare 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>;
+    stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: StreamParams<T>): Promise<Response & {
+        processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
+    }>;
     /**
      * Gets details about a specific tool available to the agent
      * @param toolId - ID of the tool to retrieve
@@ -177,6 +271,30 @@ declare class Agent extends BaseResource {
     liveEvals(): Promise<GetEvalsByAgentIdResponse>;
 }
 
+declare class Network extends BaseResource {
+    private networkId;
+    constructor(options: ClientOptions, networkId: string);
+    /**
+     * Retrieves details about the network
+     * @returns Promise containing network details
+     */
+    details(): Promise<GetNetworkResponse>;
+    /**
+     * 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>>;
+    /**
+     * Streams a response from the agent
+     * @param params - Stream parameters including prompt
+     * @returns Promise containing the enhanced Response object with processDataStream method
+     */
+    stream<T extends JSONSchema7 | ZodSchema | undefined = undefined>(params: StreamParams<T>): Promise<Response & {
+        processDataStream: (options?: Omit<Parameters<typeof processDataStream>[0], 'stream'>) => Promise<void>;
+    }>;
+}
+
 declare class MemoryThread extends BaseResource {
     private threadId;
     private agentId;
@@ -261,13 +379,34 @@ declare class Workflow extends BaseResource {
      */
     details(): Promise<GetWorkflowResponse>;
     /**
+     * @deprecated Use `startAsync` instead
      * Executes the workflow with the provided parameters
      * @param params - Parameters required for workflow execution
      * @returns Promise containing the workflow execution results
      */
-    execute(params: Record<string, any>): Promise<Record<string, any>>;
+    execute(params: Record<string, any>): Promise<WorkflowRunResult>;
     /**
-     * Resumes a suspended workflow step
+     * Creates a new workflow run
+     * @returns Promise containing the generated run ID
+     */
+    createRun(params?: {
+        runId?: string;
+    }): Promise<{
+        runId: string;
+    }>;
+    /**
+     * Starts a 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;
+    }>;
+    /**
+     * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
      * @param stepId - ID of the step to resume
      * @param runId - ID of the workflow run
      * @param context - Context to resume the workflow with
@@ -277,12 +416,44 @@ declare class Workflow extends BaseResource {
         stepId: string;
         runId: string;
         context: Record<string, any>;
-    }): Promise<Record<string, any>>;
+    }): Promise<{
+        message: string;
+    }>;
+    /**
+     * 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<WorkflowRunResult>;
+    /**
+     * Resumes a suspended 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<WorkflowRunResult>;
+    /**
+     * 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 streamProcessor;
     /**
      * Watches workflow transitions in real-time
-     * @returns Promise containing the workflow watch stream
+     * @param runId - Optional run ID to filter the watch stream
+     * @returns AsyncGenerator that yields parsed records from the workflow watch stream
      */
-    watch(): Promise<Response>;
+    watch({ runId }: {
+        runId?: string;
+    }, onRecord: (record: WorkflowRunResult) => void): Promise<void>;
 }
 
 declare class Tool extends BaseResource {
@@ -400,6 +571,17 @@ declare class MastraClient extends BaseResource {
      * @returns Promise containing telemetry data
      */
     getTelemetry(params?: GetTelemetryParams): Promise<GetTelemetryResponse>;
+    /**
+     * Retrieves all available networks
+     * @returns Promise containing map of network IDs to network details
+     */
+    getNetworks(): Promise<Record<string, GetNetworkResponse>>;
+    /**
+     * Gets a network instance by ID
+     * @param networkId - ID of the network to retrieve
+     * @returns Network instance
+     */
+    getNetwork(networkId: string): Network;
 }
 
-export { type ClientOptions, type CreateIndexParams, type CreateMemoryThreadParams, type CreateMemoryThreadResponse, type GenerateParams, type GetAgentResponse, type GetEvalsByAgentIdResponse, type GetLogParams, type GetLogsParams, type GetLogsResponse, type GetMemoryThreadMessagesResponse, type GetMemoryThreadParams, type GetMemoryThreadResponse, type GetTelemetryParams, type GetTelemetryResponse, type GetToolResponse, type GetVectorIndexResponse, type GetWorkflowResponse, MastraClient, type QueryVectorParams, type QueryVectorResponse, type RequestFunction, type RequestOptions, type SaveMessageToMemoryParams, type SaveMessageToMemoryResponse, type StreamParams, type UpdateMemoryThreadParams, type UpsertVectorParams };
+export { type ClientOptions, type CreateIndexParams, type CreateMemoryThreadParams, type CreateMemoryThreadResponse, type GenerateParams, type GetAgentResponse, type GetEvalsByAgentIdResponse, type GetLogParams, type GetLogsParams, type GetLogsResponse, type GetMemoryThreadMessagesResponse, type GetMemoryThreadParams, type GetMemoryThreadResponse, type GetNetworkResponse, type GetTelemetryParams, type GetTelemetryResponse, type GetToolResponse, type GetVectorIndexResponse, type GetWorkflowResponse, MastraClient, type QueryVectorParams, type QueryVectorResponse, type RequestFunction, type RequestOptions, type SaveMessageToMemoryParams, type SaveMessageToMemoryResponse, type StreamParams, type UpdateMemoryThreadParams, type UpsertVectorParams, type WorkflowRunResult };