@mastra/client-js 0.0.0-a2a-20250421213654 → 0.0.0-add-runtime-context-to-openai-realtime-20250516201052

package/dist/index.cjs

@@ -1,10 +1,206 @@
 'use strict';
 
-var zod = require('zod');
-var zodToJsonSchema = require('zod-to-json-schema');
+var client = require('@ag-ui/client');
+var rxjs = require('rxjs');
 var uiUtils = require('@ai-sdk/ui-utils');
+var zod = require('zod');
+var originalZodToJsonSchema = require('zod-to-json-schema');
 
-// src/resources/agent.ts
+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 {
+  agent;
+  resourceId;
+  constructor({ agent, agentId, resourceId, ...rest }) {
+    super({
+      agentId,
+      ...rest
+    });
+    this.agent = agent;
+    this.resourceId = resourceId;
+  }
+  run(input) {
+    return new rxjs.Observable((subscriber) => {
+      const convertedMessages = convertMessagesToMastraMessages(input.messages);
+      subscriber.next({
+        type: client.EventType.RUN_STARTED,
+        threadId: input.threadId,
+        runId: input.runId
+      });
+      this.agent.stream({
+        threadId: input.threadId,
+        resourceId: this.resourceId ?? "",
+        runId: input.runId,
+        messages: convertedMessages,
+        clientTools: input.tools.reduce(
+          (acc, tool) => {
+            acc[tool.name] = {
+              id: tool.name,
+              description: tool.description,
+              inputSchema: tool.parameters
+            };
+            return acc;
+          },
+          {}
+        )
+      }).then((response) => {
+        let currentMessageId = void 0;
+        let isInTextMessage = false;
+        return response.processDataStream({
+          onTextPart: (text) => {
+            if (currentMessageId === void 0) {
+              currentMessageId = generateUUID();
+              const message2 = {
+                type: client.EventType.TEXT_MESSAGE_START,
+                messageId: currentMessageId,
+                role: "assistant"
+              };
+              subscriber.next(message2);
+              isInTextMessage = true;
+            }
+            const message = {
+              type: client.EventType.TEXT_MESSAGE_CONTENT,
+              messageId: currentMessageId,
+              delta: text
+            };
+            subscriber.next(message);
+          },
+          onFinishMessagePart: () => {
+            if (currentMessageId !== void 0) {
+              const message = {
+                type: client.EventType.TEXT_MESSAGE_END,
+                messageId: currentMessageId
+              };
+              subscriber.next(message);
+              isInTextMessage = false;
+            }
+            subscriber.next({
+              type: client.EventType.RUN_FINISHED,
+              threadId: input.threadId,
+              runId: input.runId
+            });
+            subscriber.complete();
+          },
+          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,
+              toolCallName: streamPart.toolName,
+              parentMessageId
+            });
+            subscriber.next({
+              type: client.EventType.TOOL_CALL_ARGS,
+              toolCallId: streamPart.toolCallId,
+              delta: JSON.stringify(streamPart.args),
+              parentMessageId
+            });
+            subscriber.next({
+              type: client.EventType.TOOL_CALL_END,
+              toolCallId: streamPart.toolCallId,
+              parentMessageId
+            });
+          }
+        });
+      }).catch((error) => {
+        console.error("error", error);
+        subscriber.error(error);
+      });
+      return () => {
+      };
+    });
+  }
+};
+function generateUUID() {
+  if (typeof crypto !== "undefined") {
+    if (typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+    if (typeof crypto.getRandomValues === "function") {
+      const buffer = new Uint8Array(16);
+      crypto.getRandomValues(buffer);
+      buffer[6] = buffer[6] & 15 | 64;
+      buffer[8] = buffer[8] & 63 | 128;
+      let hex = "";
+      for (let i = 0; i < 16; i++) {
+        hex += buffer[i].toString(16).padStart(2, "0");
+        if (i === 3 || i === 5 || i === 7 || i === 9) hex += "-";
+      }
+      return hex;
+    }
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function convertMessagesToMastraMessages(messages) {
+  const result = [];
+  for (const message of messages) {
+    if (message.role === "assistant") {
+      const parts = message.content ? [{ type: "text", text: message.content }] : [];
+      for (const toolCall of message.toolCalls ?? []) {
+        parts.push({
+          type: "tool-call",
+          toolCallId: toolCall.id,
+          toolName: toolCall.function.name,
+          args: JSON.parse(toolCall.function.arguments)
+        });
+      }
+      result.push({
+        role: "assistant",
+        content: parts
+      });
+      if (message.toolCalls?.length) {
+        result.push({
+          role: "tool",
+          content: message.toolCalls.map((toolCall) => ({
+            type: "tool-result",
+            toolCallId: toolCall.id,
+            toolName: toolCall.function.name,
+            result: JSON.parse(toolCall.function.arguments)
+          }))
+        });
+      }
+    } else if (message.role === "user") {
+      result.push({
+        role: "user",
+        content: message.content || ""
+      });
+    } else if (message.role === "tool") {
+      result.push({
+        role: "tool",
+        content: [
+          {
+            type: "tool-result",
+            toolCallId: message.toolCallId,
+            toolName: "unknown",
+            result: message.content
+          }
+        ]
+      });
+    }
+  }
+  return result;
+}
+function zodToJsonSchema(zodSchema) {
+  if (!(zodSchema instanceof zod.ZodSchema)) {
+    return zodSchema;
+  }
+  return originalZodToJsonSchema__default.default(zodSchema, { $refStrategy: "none" });
+}
 
 // src/resources/base.ts
 var BaseResource = class {
@@ -24,7 +220,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,
@@ -135,8 +331,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
+      output: params.output ? zodToJsonSchema(params.output) : void 0,
+      experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : void 0,
+      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0
     };
     return this.request(`/api/agents/${this.agentId}/generate`, {
       method: "POST",
@@ -151,8 +348,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
+      output: params.output ? zodToJsonSchema(params.output) : void 0,
+      experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : void 0,
+      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0
     };
     const response = await this.request(`/api/agents/${this.agentId}/stream`, {
       method: "POST",
@@ -178,6 +376,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
@@ -213,8 +427,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",
@@ -229,8 +443,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",
@@ -286,10 +500,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()}`);
   }
 };
 
@@ -373,6 +592,34 @@ var Workflow = class extends BaseResource {
   details() {
     return this.request(`/api/workflows/${this.workflowId}`);
   }
+  /**
+   * Retrieves all runs for a workflow
+   * @param params - Parameters for filtering runs
+   * @returns Promise containing workflow runs array
+   */
+  runs(params) {
+    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/${this.workflowId}/runs?${searchParams}`);
+    } else {
+      return this.request(`/api/workflows/${this.workflowId}/runs`);
+    }
+  }
   /**
    * @deprecated Use `startAsync` instead
    * Executes the workflow with the provided parameters
@@ -489,7 +736,7 @@ var Workflow = class extends BaseResource {
               }
             }
           }
-        } catch (error) {
+        } catch {
         }
       }
       if (buffer) {
@@ -543,89 +790,314 @@ var Tool = class extends BaseResource {
    * @returns Promise containing the tool execution results
    */
   execute(params) {
-    return this.request(`/api/tools/${this.toolId}/execute`, {
+    const url = new URLSearchParams();
+    if (params.runId) {
+      url.set("runId", params.runId);
+    }
+    const body = {
+      data: params.data,
+      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0
+    };
+    return this.request(`/api/tools/${this.toolId}/execute?${url.toString()}`, {
       method: "POST",
-      body: params
+      body
+    });
+  }
+};
+
+// src/resources/vnext-workflow.ts
+var RECORD_SEPARATOR2 = "";
+var VNextWorkflow = 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
+   * 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_SEPARATOR2);
+          buffer = chunks.pop() || "";
+          for (const chunk of chunks) {
+            if (chunk) {
+              if (typeof chunk === "string") {
+                try {
+                  const parsedChunk = JSON.parse(chunk);
+                  yield parsedChunk;
+                } catch {
+                }
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      if (buffer) {
+        try {
+          yield JSON.parse(buffer);
+        } catch {
+        }
+      }
+    } finally {
+      reader.cancel().catch(() => {
+      });
+    }
+  }
+  /**
+   * Retrieves details about the vNext workflow
+   * @returns Promise containing vNext workflow details including steps and graphs
+   */
+  details() {
+    return this.request(`/api/workflows/v-next/${this.workflowId}`);
+  }
+  /**
+   * Retrieves all runs for a vNext workflow
+   * @param params - Parameters for filtering runs
+   * @returns Promise containing vNext workflow runs array
+   */
+  runs(params) {
+    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/v-next/${this.workflowId}/runs?${searchParams}`);
+    } else {
+      return this.request(`/api/workflows/v-next/${this.workflowId}/runs`);
+    }
+  }
+  /**
+   * Creates a new vNext workflow run
+   * @param params - Optional object containing the optional runId
+   * @returns Promise containing the runId of the created run
+   */
+  createRun(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    return this.request(`/api/workflows/v-next/${this.workflowId}/create-run?${searchParams.toString()}`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Starts a vNext 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) {
+    const runtimeContext = params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0;
+    return this.request(`/api/workflows/v-next/${this.workflowId}/start?runId=${params.runId}`, {
+      method: "POST",
+      body: { inputData: params?.inputData, runtimeContext }
+    });
+  }
+  /**
+   * Resumes a suspended vNext workflow step synchronously without waiting for the vNext workflow to complete
+   * @param params - Object containing the runId, step, resumeData and runtimeContext
+   * @returns Promise containing success message
+   */
+  resume({
+    step,
+    runId,
+    resumeData,
+    ...rest
+  }) {
+    const runtimeContext = rest.runtimeContext ? Object.fromEntries(rest.runtimeContext.entries()) : void 0;
+    return this.request(`/api/workflows/v-next/${this.workflowId}/resume?runId=${runId}`, {
+      method: "POST",
+      stream: true,
+      body: {
+        step,
+        resumeData,
+        runtimeContext
+      }
+    });
+  }
+  /**
+   * Starts a vNext workflow run asynchronously and returns a promise that resolves when the vNext workflow is complete
+   * @param params - Object containing the optional runId, inputData and runtimeContext
+   * @returns Promise containing the vNext workflow execution results
+   */
+  startAsync(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    const runtimeContext = params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0;
+    return this.request(`/api/workflows/v-next/${this.workflowId}/start-async?${searchParams.toString()}`, {
+      method: "POST",
+      body: { inputData: params.inputData, runtimeContext }
+    });
+  }
+  /**
+   * Resumes a suspended vNext workflow step asynchronously and returns a promise that resolves when the vNext workflow is complete
+   * @param params - Object containing the runId, step, resumeData and runtimeContext
+   * @returns Promise containing the vNext workflow resume results
+   */
+  resumeAsync(params) {
+    const runtimeContext = params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0;
+    return this.request(`/api/workflows/v-next/${this.workflowId}/resume-async?runId=${params.runId}`, {
+      method: "POST",
+      body: {
+        step: params.step,
+        resumeData: params.resumeData,
+        runtimeContext
+      }
     });
   }
+  /**
+   * Watches vNext 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
+   */
+  async watch({ runId }, onRecord) {
+    const response = await this.request(`/api/workflows/v-next/${this.workflowId}/watch?runId=${runId}`, {
+      stream: true
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to watch vNext workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    for await (const record of this.streamProcessor(response.body)) {
+      onRecord(record);
+    }
+  }
 };
 
 // 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`);
+  }
   /**
-   * Sends an A2A protocol request to the server
-   * @param request - The A2A protocol request
-   * @returns Promise containing the A2A protocol response
+   * Send a message to the agent and get a response
+   * @param params - Parameters for the task
+   * @returns Promise containing the task response
    */
-  sendRequest(request) {
-    return this.request("/api/a2a", {
+  async sendMessage(params) {
+    const response = await this.request(`/a2a/${this.agentId}`, {
       method: "POST",
-      body: request
+      body: {
+        method: "tasks/send",
+        params
+      }
     });
+    return { task: response.result };
   }
   /**
-   * Sends a task to an agent using the A2A protocol
-   * @param params - Parameters for sending the task
-   * @returns Promise containing the task
+   * Get the status and result of a task
+   * @param params - Parameters for querying the task
+   * @returns Promise containing the task response
    */
-  sendTask(params) {
-    const request = {
-      jsonrpc: "2.0",
-      id: `send-${Date.now()}`,
-      method: "tasks/send",
-      params
-    };
-    return this.sendRequest(request).then((response) => {
-      if ("error" in response) {
-        throw new Error(response.error.message);
+  async getTask(params) {
+    const response = await this.request(`/a2a/${this.agentId}`, {
+      method: "POST",
+      body: {
+        method: "tasks/get",
+        params
       }
-      return response.result;
     });
+    return response.result;
   }
   /**
-   * Gets a task by ID using the A2A protocol
-   * @param params - Parameters for getting the task
-   * @returns Promise containing the task
+   * Cancel a running task
+   * @param params - Parameters identifying the task to cancel
+   * @returns Promise containing the task response
    */
-  getTask(params) {
-    const request = {
-      jsonrpc: "2.0",
-      id: `get-${Date.now()}`,
-      method: "tasks/get",
-      params
-    };
-    return this.sendRequest(request).then((response) => {
-      if ("error" in response) {
-        throw new Error(response.error.message);
+  async cancelTask(params) {
+    return this.request(`/a2a/${this.agentId}`, {
+      method: "POST",
+      body: {
+        method: "tasks/cancel",
+        params
       }
-      return response.result;
     });
   }
   /**
-   * Cancels a task by ID using the A2A protocol
-   * @param params - Parameters for canceling the task
-   * @returns Promise containing the task
+   * Send a message and subscribe to streaming updates (not fully implemented)
+   * @param params - Parameters for the task
+   * @returns Promise containing the task response
    */
-  cancelTask(params) {
-    const request = {
-      jsonrpc: "2.0",
-      id: `cancel-${Date.now()}`,
-      method: "tasks/cancel",
-      params
-    };
-    return this.sendRequest(request).then((response) => {
-      if ("error" in response) {
-        throw new Error(response.error.message);
-      }
-      return response.result;
+  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;
+  }
   /**
-   * Gets the agent card for the A2A protocol
-   * @returns Promise containing the agent card
+   * Retrieves details about this specific tool from the MCP server.
+   * @returns Promise containing the tool's information (name, description, schema).
    */
-  getAgentCard() {
-    return this.request("/api/a2a/agent-card");
+  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
+    });
   }
 };
 
@@ -641,6 +1113,21 @@ var MastraClient = class extends BaseResource {
   getAgents() {
     return this.request("/api/agents");
   }
+  async getAGUI({ resourceId }) {
+    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;
+      },
+      {}
+    );
+  }
   /**
    * Gets an agent instance by ID
    * @param agentId - ID of the agent to retrieve
@@ -721,6 +1208,21 @@ 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
@@ -758,7 +1260,7 @@ var MastraClient = class extends BaseResource {
    * @returns Promise containing telemetry data
    */
   getTelemetry(params) {
-    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 searchParams = new URLSearchParams();
     if (name) {
@@ -782,6 +1284,12 @@ var MastraClient = class 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}`);
     } else {
@@ -804,34 +1312,61 @@ var MastraClient = class extends BaseResource {
     return new Network(this.options, networkId);
   }
   /**
-   * Gets an A2A protocol instance for agent-to-agent communication
-   * @returns A2A instance
+   * 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.
    */
-  getA2A() {
-    return new A2A(this.options);
+  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);
   }
 };
 
-// src/types.ts
-var TaskState = /* @__PURE__ */ ((TaskState2) => {
-  TaskState2["PENDING"] = "pending";
-  TaskState2["RUNNING"] = "running";
-  TaskState2["COMPLETED"] = "completed";
-  TaskState2["FAILED"] = "failed";
-  TaskState2["CANCELED"] = "canceled";
-  return TaskState2;
-})(TaskState || {});
-var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
-  ErrorCode2[ErrorCode2["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
-  ErrorCode2[ErrorCode2["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
-  ErrorCode2[ErrorCode2["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
-  ErrorCode2[ErrorCode2["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
-  ErrorCode2[ErrorCode2["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
-  ErrorCode2[ErrorCode2["TASK_NOT_FOUND"] = -32e3] = "TASK_NOT_FOUND";
-  ErrorCode2[ErrorCode2["TASK_NOT_CANCELABLE"] = -32001] = "TASK_NOT_CANCELABLE";
-  return ErrorCode2;
-})(ErrorCode || {});
-
-exports.ErrorCode = ErrorCode;
 exports.MastraClient = MastraClient;
-exports.TaskState = TaskState;