@mastra/client-js 0.0.0-vnext-inngest-20250508131921 → 0.0.0-vnextAgentNetwork-20250527091247

package/dist/index.cjs

@@ -4,7 +4,12 @@ var client = require('@ag-ui/client');
 var rxjs = require('rxjs');
 var uiUtils = require('@ai-sdk/ui-utils');
 var zod = require('zod');
-var zodToJsonSchema = require('zod-to-json-schema');
+var originalZodToJsonSchema = require('zod-to-json-schema');
+var runtimeContext = require('@mastra/core/runtime-context');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var originalZodToJsonSchema__default = /*#__PURE__*/_interopDefault(originalZodToJsonSchema);
 
 // src/adapters/agui.ts
 var AGUIAdapter = class extends client.AbstractAgent {
@@ -44,6 +49,7 @@ var AGUIAdapter = class extends client.AbstractAgent {
         )
       }).then((response) => {
         let currentMessageId = void 0;
+        let isInTextMessage = false;
         return response.processDataStream({
           onTextPart: (text) => {
             if (currentMessageId === void 0) {
@@ -54,6 +60,7 @@ var AGUIAdapter = class extends client.AbstractAgent {
                 role: "assistant"
               };
               subscriber.next(message2);
+              isInTextMessage = true;
             }
             const message = {
               type: client.EventType.TEXT_MESSAGE_CONTENT,
@@ -62,14 +69,14 @@ var AGUIAdapter = class extends client.AbstractAgent {
             };
             subscriber.next(message);
           },
-          onFinishMessagePart: (message) => {
-            console.log("onFinishMessagePart", message);
+          onFinishMessagePart: () => {
             if (currentMessageId !== void 0) {
-              const message2 = {
+              const message = {
                 type: client.EventType.TEXT_MESSAGE_END,
                 messageId: currentMessageId
               };
-              subscriber.next(message2);
+              subscriber.next(message);
+              isInTextMessage = false;
             }
             subscriber.next({
               type: client.EventType.RUN_FINISHED,
@@ -80,6 +87,14 @@ var AGUIAdapter = class extends client.AbstractAgent {
           },
           onToolCallPart(streamPart) {
             const parentMessageId = currentMessageId || generateUUID();
+            if (isInTextMessage) {
+              const message = {
+                type: client.EventType.TEXT_MESSAGE_END,
+                messageId: parentMessageId
+              };
+              subscriber.next(message);
+              isInTextMessage = false;
+            }
             subscriber.next({
               type: client.EventType.TOOL_CALL_START,
               toolCallId: streamPart.toolCallId,
@@ -100,7 +115,7 @@ var AGUIAdapter = class extends client.AbstractAgent {
           }
         });
       }).catch((error) => {
-        console.log("error", error);
+        console.error("error", error);
         subscriber.error(error);
       });
       return () => {
@@ -149,6 +164,17 @@ function convertMessagesToMastraMessages(messages) {
         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",
@@ -170,6 +196,12 @@ function convertMessagesToMastraMessages(messages) {
   }
   return result;
 }
+function zodToJsonSchema(zodSchema) {
+  if (!(zodSchema instanceof zod.ZodSchema)) {
+    return zodSchema;
+  }
+  return originalZodToJsonSchema__default.default(zodSchema, { $refStrategy: "none" });
+}
 
 // src/resources/base.ts
 var BaseResource = class {
@@ -189,7 +221,7 @@ var BaseResource = class {
     let delay = backoffMs;
     for (let attempt = 0; attempt <= retries; attempt++) {
       try {
-        const response = await fetch(`${baseUrl}${path}`, {
+        const response = await fetch(`${baseUrl.replace(/\/$/, "")}${path}`, {
           ...options,
           headers: {
             ...headers,
@@ -229,6 +261,15 @@ var BaseResource = class {
     throw lastError || new Error("Request failed");
   }
 };
+function parseClientRuntimeContext(runtimeContext$1) {
+  if (runtimeContext$1) {
+    if (runtimeContext$1 instanceof runtimeContext.RuntimeContext) {
+      return Object.fromEntries(runtimeContext$1.entries());
+    }
+    return runtimeContext$1;
+  }
+  return void 0;
+}
 
 // src/resources/agent.ts
 var AgentVoice = class extends BaseResource {
@@ -300,9 +341,9 @@ var Agent = class extends BaseResource {
   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,
-      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0
+      output: params.output ? zodToJsonSchema(params.output) : void 0,
+      experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : void 0,
+      runtimeContext: parseClientRuntimeContext(params.runtimeContext)
     };
     return this.request(`/api/agents/${this.agentId}/generate`, {
       method: "POST",
@@ -317,9 +358,9 @@ var Agent = class extends BaseResource {
   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,
-      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0
+      output: params.output ? zodToJsonSchema(params.output) : void 0,
+      experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : void 0,
+      runtimeContext: parseClientRuntimeContext(params.runtimeContext)
     };
     const response = await this.request(`/api/agents/${this.agentId}/stream`, {
       method: "POST",
@@ -345,6 +386,22 @@ var Agent = class extends BaseResource {
   getTool(toolId) {
     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, params) {
+    const body = {
+      data: params.data,
+      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0
+    };
+    return this.request(`/api/agents/${this.agentId}/tools/${toolId}/execute`, {
+      method: "POST",
+      body
+    });
+  }
   /**
    * Retrieves evaluation results for the agent
    * @returns Promise containing agent evaluations
@@ -380,8 +437,8 @@ var Network = class extends BaseResource {
   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
+      output: zodToJsonSchema(params.output),
+      experimental_output: zodToJsonSchema(params.experimental_output)
     };
     return this.request(`/api/networks/${this.networkId}/generate`, {
       method: "POST",
@@ -396,8 +453,8 @@ var Network = class extends BaseResource {
   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
+      output: zodToJsonSchema(params.output),
+      experimental_output: zodToJsonSchema(params.experimental_output)
     };
     const response = await this.request(`/api/networks/${this.networkId}/stream`, {
       method: "POST",
@@ -453,10 +510,15 @@ var MemoryThread = class 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() {
-    return this.request(`/api/memory/threads/${this.threadId}/messages?agentId=${this.agentId}`);
+  getMessages(params) {
+    const query = new URLSearchParams({
+      agentId: this.agentId,
+      ...params?.limit ? { limit: params.limit.toString() } : {}
+    });
+    return this.request(`/api/memory/threads/${this.threadId}/messages?${query.toString()}`);
   }
 };
 
@@ -526,24 +588,24 @@ var Vector = class extends BaseResource {
   }
 };
 
-// src/resources/workflow.ts
+// src/resources/legacy-workflow.ts
 var RECORD_SEPARATOR = "";
-var Workflow = class extends BaseResource {
+var LegacyWorkflow = class extends BaseResource {
   constructor(options, workflowId) {
     super(options);
     this.workflowId = workflowId;
   }
   /**
-   * Retrieves details about the workflow
-   * @returns Promise containing workflow details including steps and graphs
+   * Retrieves details about the legacy workflow
+   * @returns Promise containing legacy workflow details including steps and graphs
    */
   details() {
-    return this.request(`/api/workflows/${this.workflowId}`);
+    return this.request(`/api/workflows/legacy/${this.workflowId}`);
   }
   /**
-   * Retrieves all runs for a workflow
+   * Retrieves all runs for a legacy workflow
    * @param params - Parameters for filtering runs
-   * @returns Promise containing workflow runs array
+   * @returns Promise containing legacy workflow runs array
    */
   runs(params) {
     const searchParams = new URLSearchParams();
@@ -563,25 +625,13 @@ var Workflow = class extends BaseResource {
       searchParams.set("resourceId", params.resourceId);
     }
     if (searchParams.size) {
-      return this.request(`/api/workflows/${this.workflowId}/runs?${searchParams}`);
+      return this.request(`/api/workflows/legacy/${this.workflowId}/runs?${searchParams}`);
     } else {
-      return this.request(`/api/workflows/${this.workflowId}/runs`);
+      return this.request(`/api/workflows/legacy/${this.workflowId}/runs`);
     }
   }
   /**
-   * @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) {
-    return this.request(`/api/workflows/${this.workflowId}/execute`, {
-      method: "POST",
-      body: params
-    });
-  }
-  /**
-   * Creates a new workflow run
+   * Creates a new legacy workflow run
    * @returns Promise containing the generated run ID
    */
   createRun(params) {
@@ -589,34 +639,34 @@ var Workflow = class extends BaseResource {
     if (!!params?.runId) {
       searchParams.set("runId", params.runId);
     }
-    return this.request(`/api/workflows/${this.workflowId}/createRun?${searchParams.toString()}`, {
+    return this.request(`/api/workflows/legacy/${this.workflowId}/create-run?${searchParams.toString()}`, {
       method: "POST"
     });
   }
   /**
-   * Starts a workflow run synchronously without waiting for the workflow to complete
+   * 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) {
-    return this.request(`/api/workflows/${this.workflowId}/start?runId=${params.runId}`, {
+    return this.request(`/api/workflows/legacy/${this.workflowId}/start?runId=${params.runId}`, {
       method: "POST",
       body: params?.triggerData
     });
   }
   /**
-   * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
+   * 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 workflow run
-   * @param context - Context to resume the workflow with
-   * @returns Promise containing the workflow resume results
+   * @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
   }) {
-    return this.request(`/api/workflows/${this.workflowId}/resume?runId=${runId}`, {
+    return this.request(`/api/workflows/legacy/${this.workflowId}/resume?runId=${runId}`, {
       method: "POST",
       body: {
         stepId,
@@ -634,18 +684,18 @@ var Workflow = class extends BaseResource {
     if (!!params?.runId) {
       searchParams.set("runId", params.runId);
     }
-    return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
+    return this.request(`/api/workflows/legacy/${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
+   * 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) {
-    return this.request(`/api/workflows/${this.workflowId}/resume-async?runId=${params.runId}`, {
+    return this.request(`/api/workflows/legacy/${this.workflowId}/resume-async?runId=${params.runId}`, {
       method: "POST",
       body: {
         stepId: params.stepId,
@@ -699,16 +749,16 @@ var Workflow = class extends BaseResource {
     }
   }
   /**
-   * Watches workflow transitions in real-time
+   * 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 workflow watch stream
+   * @returns AsyncGenerator that yields parsed records from the legacy workflow watch stream
    */
   async watch({ runId }, onRecord) {
-    const response = await this.request(`/api/workflows/${this.workflowId}/watch?runId=${runId}`, {
+    const response = await this.request(`/api/workflows/legacy/${this.workflowId}/watch?runId=${runId}`, {
       stream: true
     });
     if (!response.ok) {
-      throw new Error(`Failed to watch workflow: ${response.statusText}`);
+      throw new Error(`Failed to watch legacy workflow: ${response.statusText}`);
     }
     if (!response.body) {
       throw new Error("Response body is null");
@@ -742,22 +792,26 @@ var Tool = class extends BaseResource {
     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.data
+      body
     });
   }
 };
 
-// src/resources/vnext-workflow.ts
+// src/resources/workflow.ts
 var RECORD_SEPARATOR2 = "";
-var VNextWorkflow = class extends BaseResource {
+var Workflow = class extends BaseResource {
   constructor(options, workflowId) {
     super(options);
     this.workflowId = workflowId;
   }
   /**
-   * Creates an async generator that processes a readable stream and yields vNext workflow records
+   * Creates an async generator that processes a readable stream and yields workflow records
    * separated by the Record Separator character (\x1E)
    *
    * @param stream - The readable stream to process
@@ -802,16 +856,16 @@ var VNextWorkflow = class extends BaseResource {
     }
   }
   /**
-   * Retrieves details about the vNext workflow
-   * @returns Promise containing vNext workflow details including steps and graphs
+   * Retrieves details about the workflow
+   * @returns Promise containing workflow details including steps and graphs
    */
   details() {
-    return this.request(`/api/workflows/v-next/${this.workflowId}`);
+    return this.request(`/api/workflows/${this.workflowId}`);
   }
   /**
-   * Retrieves all runs for a vNext workflow
+   * Retrieves all runs for a workflow
    * @param params - Parameters for filtering runs
-   * @returns Promise containing vNext workflow runs array
+   * @returns Promise containing workflow runs array
    */
   runs(params) {
     const searchParams = new URLSearchParams();
@@ -831,13 +885,13 @@ var VNextWorkflow = class extends BaseResource {
       searchParams.set("resourceId", params.resourceId);
     }
     if (searchParams.size) {
-      return this.request(`/api/workflows/v-next/${this.workflowId}/runs?${searchParams}`);
+      return this.request(`/api/workflows/${this.workflowId}/runs?${searchParams}`);
     } else {
-      return this.request(`/api/workflows/v-next/${this.workflowId}/runs`);
+      return this.request(`/api/workflows/${this.workflowId}/runs`);
     }
   }
   /**
-   * Creates a new vNext workflow run
+   * Creates a new workflow run
    * @param params - Optional object containing the optional runId
    * @returns Promise containing the runId of the created run
    */
@@ -846,23 +900,24 @@ var VNextWorkflow = class extends BaseResource {
     if (!!params?.runId) {
       searchParams.set("runId", params.runId);
     }
-    return this.request(`/api/workflows/v-next/${this.workflowId}/create-run?${searchParams.toString()}`, {
+    return this.request(`/api/workflows/${this.workflowId}/create-run?${searchParams.toString()}`, {
       method: "POST"
     });
   }
   /**
-   * Starts a vNext workflow run synchronously without waiting for the workflow to complete
+   * Starts a workflow run synchronously without waiting for the workflow to complete
    * @param params - Object containing the runId, inputData and runtimeContext
    * @returns Promise containing success message
    */
   start(params) {
-    return this.request(`/api/workflows/v-next/${this.workflowId}/start?runId=${params.runId}`, {
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    return this.request(`/api/workflows/${this.workflowId}/start?runId=${params.runId}`, {
       method: "POST",
-      body: { inputData: params?.inputData, runtimeContext: params.runtimeContext }
+      body: { inputData: params?.inputData, runtimeContext }
     });
   }
   /**
-   * Resumes a suspended vNext workflow step synchronously without waiting for the vNext workflow to complete
+   * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
    * @param params - Object containing the runId, step, resumeData and runtimeContext
    * @returns Promise containing success message
    */
@@ -870,9 +925,10 @@ var VNextWorkflow = class extends BaseResource {
     step,
     runId,
     resumeData,
-    runtimeContext
+    ...rest
   }) {
-    return this.request(`/api/workflows/v-next/${this.workflowId}/resume?runId=${runId}`, {
+    const runtimeContext = parseClientRuntimeContext(rest.runtimeContext);
+    return this.request(`/api/workflows/${this.workflowId}/resume?runId=${runId}`, {
       method: "POST",
       stream: true,
       body: {
@@ -883,46 +939,95 @@ var VNextWorkflow = class extends BaseResource {
     });
   }
   /**
-   * Starts a vNext workflow run asynchronously and returns a promise that resolves when the vNext workflow is complete
+   * Starts a workflow run asynchronously and returns a promise that resolves when the workflow is complete
    * @param params - Object containing the optional runId, inputData and runtimeContext
-   * @returns Promise containing the vNext workflow execution results
+   * @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/v-next/${this.workflowId}/start-async?${searchParams.toString()}`, {
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
       method: "POST",
-      body: { inputData: params.inputData, runtimeContext: params.runtimeContext }
+      body: { inputData: params.inputData, runtimeContext }
+    });
+  }
+  /**
+   * Starts a vNext workflow run and returns a stream
+   * @param params - Object containing the optional runId, inputData and runtimeContext
+   * @returns Promise containing the vNext workflow execution results
+   */
+  async stream(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    const runtimeContext = params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0;
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/stream?${searchParams.toString()}`,
+      {
+        method: "POST",
+        body: { inputData: params.inputData, runtimeContext },
+        stream: true
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to stream vNext workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR2);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              try {
+                const parsedChunk = JSON.parse(chunk2);
+                controller.enqueue(parsedChunk);
+              } catch {
+              }
+            }
+          }
+        } catch {
+        }
+      }
     });
+    return response.body.pipeThrough(transformStream);
   }
   /**
-   * Resumes a suspended vNext workflow step asynchronously and returns a promise that resolves when the vNext workflow is complete
+   * Resumes a suspended workflow step asynchronously and returns a promise that resolves when the workflow is complete
    * @param params - Object containing the runId, step, resumeData and runtimeContext
-   * @returns Promise containing the vNext workflow resume results
+   * @returns Promise containing the workflow resume results
    */
   resumeAsync(params) {
-    return this.request(`/api/workflows/v-next/${this.workflowId}/resume-async?runId=${params.runId}`, {
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    return this.request(`/api/workflows/${this.workflowId}/resume-async?runId=${params.runId}`, {
       method: "POST",
       body: {
         step: params.step,
         resumeData: params.resumeData,
-        runtimeContext: params.runtimeContext
+        runtimeContext
       }
     });
   }
   /**
-   * Watches vNext workflow transitions in real-time
+   * Watches workflow transitions in real-time
    * @param runId - Optional run ID to filter the watch stream
-   * @returns AsyncGenerator that yields parsed records from the vNext workflow watch stream
+   * @returns AsyncGenerator that yields parsed records from the workflow watch stream
    */
   async watch({ runId }, onRecord) {
-    const response = await this.request(`/api/workflows/v-next/${this.workflowId}/watch?runId=${runId}`, {
+    const response = await this.request(`/api/workflows/${this.workflowId}/watch?runId=${runId}`, {
       stream: true
     });
     if (!response.ok) {
-      throw new Error(`Failed to watch vNext workflow: ${response.statusText}`);
+      throw new Error(`Failed to watch workflow: ${response.statusText}`);
     }
     if (!response.body) {
       throw new Error("Response body is null");
@@ -931,6 +1036,137 @@ var VNextWorkflow = class extends BaseResource {
       onRecord(record);
     }
   }
+  /**
+   * Creates a new ReadableStream from an iterable or async iterable of objects,
+   * serializing each as JSON and separating them with the record separator (\x1E).
+   *
+   * @param records - An iterable or async iterable of objects to stream
+   * @returns A ReadableStream emitting the records as JSON strings separated by the record separator
+   */
+  static createRecordStream(records) {
+    const encoder = new TextEncoder();
+    return new ReadableStream({
+      async start(controller) {
+        try {
+          for await (const record of records) {
+            const json = JSON.stringify(record) + RECORD_SEPARATOR2;
+            controller.enqueue(encoder.encode(json));
+          }
+          controller.close();
+        } catch (err) {
+          controller.error(err);
+        }
+      }
+    });
+  }
+};
+
+// src/resources/a2a.ts
+var A2A = class extends BaseResource {
+  constructor(options, agentId) {
+    super(options);
+    this.agentId = agentId;
+  }
+  /**
+   * Get the agent card with metadata about the agent
+   * @returns Promise containing the agent card information
+   */
+  async getCard() {
+    return this.request(`/.well-known/${this.agentId}/agent.json`);
+  }
+  /**
+   * Send a message to the agent and get a response
+   * @param params - Parameters for the task
+   * @returns Promise containing the task response
+   */
+  async sendMessage(params) {
+    const response = await this.request(`/a2a/${this.agentId}`, {
+      method: "POST",
+      body: {
+        method: "tasks/send",
+        params
+      }
+    });
+    return { task: response.result };
+  }
+  /**
+   * Get the status and result of a task
+   * @param params - Parameters for querying the task
+   * @returns Promise containing the task response
+   */
+  async getTask(params) {
+    const response = await this.request(`/a2a/${this.agentId}`, {
+      method: "POST",
+      body: {
+        method: "tasks/get",
+        params
+      }
+    });
+    return response.result;
+  }
+  /**
+   * Cancel a running task
+   * @param params - Parameters identifying the task to cancel
+   * @returns Promise containing the task response
+   */
+  async cancelTask(params) {
+    return this.request(`/a2a/${this.agentId}`, {
+      method: "POST",
+      body: {
+        method: "tasks/cancel",
+        params
+      }
+    });
+  }
+  /**
+   * Send a message and subscribe to streaming updates (not fully implemented)
+   * @param params - Parameters for the task
+   * @returns Promise containing the task response
+   */
+  async sendAndSubscribe(params) {
+    return this.request(`/a2a/${this.agentId}`, {
+      method: "POST",
+      body: {
+        method: "tasks/sendSubscribe",
+        params
+      },
+      stream: true
+    });
+  }
+};
+
+// src/resources/mcp-tool.ts
+var MCPTool = class extends BaseResource {
+  serverId;
+  toolId;
+  constructor(options, serverId, toolId) {
+    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() {
+    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) {
+    const body = {};
+    if (params.data !== void 0) body.data = params.data;
+    if (params.runtimeContext !== void 0) {
+      body.runtimeContext = params.runtimeContext;
+    }
+    return this.request(`/api/mcp/${this.serverId}/tools/${this.toolId}/execute`, {
+      method: "POST",
+      body: Object.keys(body).length > 0 ? body : void 0
+    });
+  }
 };
 
 // src/client.ts
@@ -1025,6 +1261,21 @@ var MastraClient = class extends BaseResource {
   getTool(toolId) {
     return new Tool(this.options, toolId);
   }
+  /**
+   * Retrieves all available legacy workflows
+   * @returns Promise containing map of legacy workflow IDs to legacy workflow details
+   */
+  getLegacyWorkflows() {
+    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
+   */
+  getLegacyWorkflow(workflowId) {
+    return new LegacyWorkflow(this.options, workflowId);
+  }
   /**
    * Retrieves all available workflows
    * @returns Promise containing map of workflow IDs to workflow details
@@ -1040,21 +1291,6 @@ var MastraClient = class extends BaseResource {
   getWorkflow(workflowId) {
     return new Workflow(this.options, workflowId);
   }
-  /**
-   * Retrieves all available vNext workflows
-   * @returns Promise containing map of vNext workflow IDs to vNext workflow details
-   */
-  getVNextWorkflows() {
-    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
-   */
-  getVNextWorkflow(workflowId) {
-    return new VNextWorkflow(this.options, workflowId);
-  }
   /**
    * Gets a vector instance by name
    * @param vectorName - Name of the vector to retrieve
@@ -1143,6 +1379,62 @@ var MastraClient = class extends BaseResource {
   getNetwork(networkId) {
     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.
+   */
+  getMcpServers(params) {
+    const searchParams = new URLSearchParams();
+    if (params?.limit !== void 0) {
+      searchParams.set("limit", String(params.limit));
+    }
+    if (params?.offset !== void 0) {
+      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.
+   */
+  getMcpServerDetails(serverId, params) {
+    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.
+   */
+  getMcpServerTools(serverId) {
+    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.
+   */
+  getMcpServerTool(serverId, toolId) {
+    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
+   */
+  getA2A(agentId) {
+    return new A2A(this.options, agentId);
+  }
 };
 
 exports.MastraClient = MastraClient;