@mastra/client-js 0.0.0-bundle-dynamic-imports-20250424001248 → 0.0.0-bundle-recursion-20251030002519

package/dist/index.js

@@ -1,8 +1,135 @@
-import { ZodSchema } from 'zod';
-import { zodToJsonSchema } from 'zod-to-json-schema';
-import { processDataStream } from '@ai-sdk/ui-utils';
+import { processDataStream, parsePartialJson } from '@ai-sdk/ui-utils';
+import { v4 } from '@lukeed/uuid';
+import { getErrorFromUnknown } from '@mastra/core/error';
+import { RuntimeContext } from '@mastra/core/runtime-context';
+import { isVercelTool } from '@mastra/core/tools/is-vercel-tool';
+import { z } from 'zod';
+import originalZodToJsonSchema from 'zod-to-json-schema';
 
 // src/resources/agent.ts
+function parseClientRuntimeContext(runtimeContext) {
+  if (runtimeContext) {
+    if (runtimeContext instanceof RuntimeContext) {
+      return Object.fromEntries(runtimeContext.entries());
+    }
+    return runtimeContext;
+  }
+  return void 0;
+}
+function base64RuntimeContext(runtimeContext) {
+  if (runtimeContext) {
+    return btoa(JSON.stringify(runtimeContext));
+  }
+  return void 0;
+}
+function runtimeContextQueryString(runtimeContext, delimiter = "?") {
+  const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
+  if (!runtimeContextParam) return "";
+  const searchParams = new URLSearchParams();
+  searchParams.set("runtimeContext", runtimeContextParam);
+  const queryString = searchParams.toString();
+  return queryString ? `${delimiter}${queryString}` : "";
+}
+function isZodType(value) {
+  return typeof value === "object" && value !== null && "_def" in value && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
+}
+function zodToJsonSchema(zodSchema) {
+  if (!isZodType(zodSchema)) {
+    return zodSchema;
+  }
+  if ("toJSONSchema" in z) {
+    const fn = "toJSONSchema";
+    return z[fn].call(z, zodSchema);
+  }
+  return originalZodToJsonSchema(zodSchema, { $refStrategy: "relative" });
+}
+
+// src/utils/process-client-tools.ts
+function processClientTools(clientTools) {
+  if (!clientTools) {
+    return void 0;
+  }
+  return Object.fromEntries(
+    Object.entries(clientTools).map(([key, value]) => {
+      if (isVercelTool(value)) {
+        return [
+          key,
+          {
+            ...value,
+            parameters: value.parameters ? zodToJsonSchema(value.parameters) : void 0
+          }
+        ];
+      } else {
+        return [
+          key,
+          {
+            ...value,
+            inputSchema: value.inputSchema ? zodToJsonSchema(value.inputSchema) : void 0,
+            outputSchema: value.outputSchema ? zodToJsonSchema(value.outputSchema) : void 0
+          }
+        ];
+      }
+    })
+  );
+}
+
+// src/utils/process-mastra-stream.ts
+async function sharedProcessMastraStream({
+  stream,
+  onChunk
+}) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const data = line.slice(6);
+          if (data === "[DONE]") {
+            console.info("\u{1F3C1} Stream finished");
+            return;
+          }
+          let json;
+          try {
+            json = JSON.parse(data);
+          } catch (error) {
+            console.error("\u274C JSON parse error:", error, "Data:", data);
+            continue;
+          }
+          if (json) {
+            await onChunk(json);
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function processMastraNetworkStream({
+  stream,
+  onChunk
+}) {
+  return sharedProcessMastraStream({
+    stream,
+    onChunk
+  });
+}
+async function processMastraStream({
+  stream,
+  onChunk
+}) {
+  return sharedProcessMastraStream({
+    stream,
+    onChunk
+  });
+}
 
 // src/resources/base.ts
 var BaseResource = class {
@@ -18,18 +145,21 @@ var BaseResource = class {
    */
   async request(path, options = {}) {
     let lastError = null;
-    const { baseUrl, retries = 3, backoffMs = 100, maxBackoffMs = 1e3, headers = {} } = this.options;
+    const { baseUrl, retries = 3, backoffMs = 100, maxBackoffMs = 1e3, headers = {}, credentials } = this.options;
     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: {
+            ...options.body && !(options.body instanceof FormData) && (options.method === "POST" || options.method === "PUT") ? { "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',
           },
+          signal: this.options.abortSignal,
+          credentials: options.credentials ?? credentials,
           body: options.body instanceof FormData ? options.body : options.body ? JSON.stringify(options.body) : void 0
         });
         if (!response.ok) {
@@ -64,6 +194,61 @@ var BaseResource = class {
 };
 
 // src/resources/agent.ts
+async function executeToolCallAndRespond({
+  response,
+  params,
+  runId,
+  resourceId,
+  threadId,
+  runtimeContext,
+  respondFn
+}) {
+  if (response.finishReason === "tool-calls") {
+    const toolCalls = response.toolCalls;
+    if (!toolCalls || !Array.isArray(toolCalls)) {
+      return response;
+    }
+    for (const toolCall of toolCalls) {
+      const clientTool = params.clientTools?.[toolCall.toolName];
+      if (clientTool && clientTool.execute) {
+        const result = await clientTool.execute(
+          {
+            context: toolCall?.args,
+            runId,
+            resourceId,
+            threadId,
+            runtimeContext,
+            tracingContext: { currentSpan: void 0 },
+            suspend: async () => {
+            }
+          },
+          {
+            messages: response.messages,
+            toolCallId: toolCall?.toolCallId
+          }
+        );
+        const updatedMessages = [
+          ...response.response.messages || [],
+          {
+            role: "tool",
+            content: [
+              {
+                type: "tool-result",
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                result
+              }
+            ]
+          }
+        ];
+        return respondFn({
+          ...params,
+          messages: updatedMessages
+        });
+      }
+    }
+  }
+}
 var AgentVoice = class extends BaseResource {
   constructor(options, agentId) {
     super(options);
@@ -105,10 +290,21 @@ var AgentVoice = class extends BaseResource {
   }
   /**
    * Get available speakers for the agent's voice provider
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing list of available speakers
    */
-  getSpeakers() {
-    return this.request(`/api/agents/${this.agentId}/voice/speakers`);
+  getSpeakers(runtimeContext) {
+    return this.request(`/api/agents/${this.agentId}/voice/speakers${runtimeContextQueryString(runtimeContext)}`);
+  }
+  /**
+   * Get the listener configuration for the agent's voice provider
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @returns Promise containing a check if the agent has listening capabilities
+   */
+  getListener(runtimeContext) {
+    return this.request(`/api/agents/${this.agentId}/voice/listener${runtimeContextQueryString(runtimeContext)}`);
   }
 };
 var Agent = class extends BaseResource {
@@ -120,39 +316,677 @@ var Agent = class extends BaseResource {
   voice;
   /**
    * Retrieves details about the agent
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing agent details including model and instructions
    */
-  details() {
-    return this.request(`/api/agents/${this.agentId}`);
+  details(runtimeContext) {
+    return this.request(`/api/agents/${this.agentId}${runtimeContextQueryString(runtimeContext)}`);
   }
-  /**
-   * Generates a response from the agent
-   * @param params - Generation parameters including prompt
-   * @returns Promise containing the generated response
-   */
-  generate(params) {
+  enhanceInstructions(instructions, comment) {
+    return this.request(`/api/agents/${this.agentId}/instructions/enhance`, {
+      method: "POST",
+      body: { instructions, comment }
+    });
+  }
+  async generateLegacy(params) {
     const processedParams = {
       ...params,
-      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
-      experimental_output: params.experimental_output instanceof ZodSchema ? 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: parseClientRuntimeContext(params.runtimeContext),
+      clientTools: processClientTools(params.clientTools)
     };
-    return this.request(`/api/agents/${this.agentId}/generate`, {
-      method: "POST",
-      body: processedParams
+    const { runId, resourceId, threadId, runtimeContext } = processedParams;
+    const response = await this.request(
+      `/api/agents/${this.agentId}/generate-legacy`,
+      {
+        method: "POST",
+        body: processedParams
+      }
+    );
+    if (response.finishReason === "tool-calls") {
+      const toolCalls = response.toolCalls;
+      if (!toolCalls || !Array.isArray(toolCalls)) {
+        return response;
+      }
+      for (const toolCall of toolCalls) {
+        const clientTool = params.clientTools?.[toolCall.toolName];
+        if (clientTool && clientTool.execute) {
+          const result = await clientTool.execute(
+            {
+              context: toolCall?.args,
+              runId,
+              resourceId,
+              threadId,
+              runtimeContext,
+              tracingContext: { currentSpan: void 0 },
+              suspend: async () => {
+              }
+            },
+            {
+              messages: response.messages,
+              toolCallId: toolCall?.toolCallId
+            }
+          );
+          const updatedMessages = [
+            ...response.response.messages,
+            {
+              role: "tool",
+              content: [
+                {
+                  type: "tool-result",
+                  toolCallId: toolCall.toolCallId,
+                  toolName: toolCall.toolName,
+                  result
+                }
+              ]
+            }
+          ];
+          return this.generate({
+            ...params,
+            messages: updatedMessages
+          });
+        }
+      }
+    }
+    return response;
+  }
+  async generate(messagesOrParams, options) {
+    let params;
+    if (typeof messagesOrParams === "object" && "messages" in messagesOrParams) {
+      params = messagesOrParams;
+    } else {
+      params = {
+        messages: messagesOrParams,
+        ...options
+      };
+    }
+    const processedParams = {
+      ...params,
+      runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      clientTools: processClientTools(params.clientTools),
+      structuredOutput: params.structuredOutput ? {
+        ...params.structuredOutput,
+        schema: zodToJsonSchema(params.structuredOutput.schema)
+      } : void 0
+    };
+    const { runId, resourceId, threadId, runtimeContext } = processedParams;
+    const response = await this.request(
+      `/api/agents/${this.agentId}/generate`,
+      {
+        method: "POST",
+        body: processedParams
+      }
+    );
+    if (response.finishReason === "tool-calls") {
+      return executeToolCallAndRespond({
+        response,
+        params,
+        runId,
+        resourceId,
+        threadId,
+        runtimeContext,
+        respondFn: this.generate.bind(this)
+      });
+    }
+    return response;
+  }
+  async processChatResponse({
+    stream,
+    update,
+    onToolCall,
+    onFinish,
+    getCurrentDate = () => /* @__PURE__ */ new Date(),
+    lastMessage
+  }) {
+    const replaceLastMessage = lastMessage?.role === "assistant";
+    let step = replaceLastMessage ? 1 + // find max step in existing tool invocations:
+    (lastMessage.toolInvocations?.reduce((max, toolInvocation) => {
+      return Math.max(max, toolInvocation.step ?? 0);
+    }, 0) ?? 0) : 0;
+    const message = replaceLastMessage ? structuredClone(lastMessage) : {
+      id: v4(),
+      createdAt: getCurrentDate(),
+      role: "assistant",
+      content: "",
+      parts: []
+    };
+    let currentTextPart = void 0;
+    let currentReasoningPart = void 0;
+    let currentReasoningTextDetail = void 0;
+    function updateToolInvocationPart(toolCallId, invocation) {
+      const part = message.parts.find(
+        (part2) => part2.type === "tool-invocation" && part2.toolInvocation.toolCallId === toolCallId
+      );
+      if (part != null) {
+        part.toolInvocation = invocation;
+      } else {
+        message.parts.push({
+          type: "tool-invocation",
+          toolInvocation: invocation
+        });
+      }
+    }
+    const data = [];
+    let messageAnnotations = replaceLastMessage ? lastMessage?.annotations : void 0;
+    const partialToolCalls = {};
+    let usage = {
+      completionTokens: NaN,
+      promptTokens: NaN,
+      totalTokens: NaN
+    };
+    let finishReason = "unknown";
+    function execUpdate() {
+      const copiedData = [...data];
+      if (messageAnnotations?.length) {
+        message.annotations = messageAnnotations;
+      }
+      const copiedMessage = {
+        // deep copy the message to ensure that deep changes (msg attachments) are updated
+        // with SolidJS. SolidJS uses referential integration of sub-objects to detect changes.
+        ...structuredClone(message),
+        // add a revision id to ensure that the message is updated with SWR. SWR uses a
+        // hashing approach by default to detect changes, but it only works for shallow
+        // changes. This is why we need to add a revision id to ensure that the message
+        // is updated with SWR (without it, the changes get stuck in SWR and are not
+        // forwarded to rendering):
+        revisionId: v4()
+      };
+      update({
+        message: copiedMessage,
+        data: copiedData,
+        replaceLastMessage
+      });
+    }
+    await processDataStream({
+      stream,
+      onTextPart(value) {
+        if (currentTextPart == null) {
+          currentTextPart = {
+            type: "text",
+            text: value
+          };
+          message.parts.push(currentTextPart);
+        } else {
+          currentTextPart.text += value;
+        }
+        message.content += value;
+        execUpdate();
+      },
+      onReasoningPart(value) {
+        if (currentReasoningTextDetail == null) {
+          currentReasoningTextDetail = { type: "text", text: value };
+          if (currentReasoningPart != null) {
+            currentReasoningPart.details.push(currentReasoningTextDetail);
+          }
+        } else {
+          currentReasoningTextDetail.text += value;
+        }
+        if (currentReasoningPart == null) {
+          currentReasoningPart = {
+            type: "reasoning",
+            reasoning: value,
+            details: [currentReasoningTextDetail]
+          };
+          message.parts.push(currentReasoningPart);
+        } else {
+          currentReasoningPart.reasoning += value;
+        }
+        message.reasoning = (message.reasoning ?? "") + value;
+        execUpdate();
+      },
+      onReasoningSignaturePart(value) {
+        if (currentReasoningTextDetail != null) {
+          currentReasoningTextDetail.signature = value.signature;
+        }
+      },
+      onRedactedReasoningPart(value) {
+        if (currentReasoningPart == null) {
+          currentReasoningPart = {
+            type: "reasoning",
+            reasoning: "",
+            details: []
+          };
+          message.parts.push(currentReasoningPart);
+        }
+        currentReasoningPart.details.push({
+          type: "redacted",
+          data: value.data
+        });
+        currentReasoningTextDetail = void 0;
+        execUpdate();
+      },
+      onFilePart(value) {
+        message.parts.push({
+          type: "file",
+          mimeType: value.mimeType,
+          data: value.data
+        });
+        execUpdate();
+      },
+      onSourcePart(value) {
+        message.parts.push({
+          type: "source",
+          source: value
+        });
+        execUpdate();
+      },
+      onToolCallStreamingStartPart(value) {
+        if (message.toolInvocations == null) {
+          message.toolInvocations = [];
+        }
+        partialToolCalls[value.toolCallId] = {
+          text: "",
+          step,
+          toolName: value.toolName,
+          index: message.toolInvocations.length
+        };
+        const invocation = {
+          state: "partial-call",
+          step,
+          toolCallId: value.toolCallId,
+          toolName: value.toolName,
+          args: void 0
+        };
+        message.toolInvocations.push(invocation);
+        updateToolInvocationPart(value.toolCallId, invocation);
+        execUpdate();
+      },
+      onToolCallDeltaPart(value) {
+        const partialToolCall = partialToolCalls[value.toolCallId];
+        partialToolCall.text += value.argsTextDelta;
+        const { value: partialArgs } = parsePartialJson(partialToolCall.text);
+        const invocation = {
+          state: "partial-call",
+          step: partialToolCall.step,
+          toolCallId: value.toolCallId,
+          toolName: partialToolCall.toolName,
+          args: partialArgs
+        };
+        message.toolInvocations[partialToolCall.index] = invocation;
+        updateToolInvocationPart(value.toolCallId, invocation);
+        execUpdate();
+      },
+      async onToolCallPart(value) {
+        const invocation = {
+          state: "call",
+          step,
+          ...value
+        };
+        if (partialToolCalls[value.toolCallId] != null) {
+          message.toolInvocations[partialToolCalls[value.toolCallId].index] = invocation;
+        } else {
+          if (message.toolInvocations == null) {
+            message.toolInvocations = [];
+          }
+          message.toolInvocations.push(invocation);
+        }
+        updateToolInvocationPart(value.toolCallId, invocation);
+        execUpdate();
+        if (onToolCall) {
+          const result = await onToolCall({ toolCall: value });
+          if (result != null) {
+            const invocation2 = {
+              state: "result",
+              step,
+              ...value,
+              result
+            };
+            message.toolInvocations[message.toolInvocations.length - 1] = invocation2;
+            updateToolInvocationPart(value.toolCallId, invocation2);
+            execUpdate();
+          }
+        }
+      },
+      onToolResultPart(value) {
+        const toolInvocations = message.toolInvocations;
+        if (toolInvocations == null) {
+          throw new Error("tool_result must be preceded by a tool_call");
+        }
+        const toolInvocationIndex = toolInvocations.findIndex((invocation2) => invocation2.toolCallId === value.toolCallId);
+        if (toolInvocationIndex === -1) {
+          throw new Error("tool_result must be preceded by a tool_call with the same toolCallId");
+        }
+        const invocation = {
+          ...toolInvocations[toolInvocationIndex],
+          state: "result",
+          ...value
+        };
+        toolInvocations[toolInvocationIndex] = invocation;
+        updateToolInvocationPart(value.toolCallId, invocation);
+        execUpdate();
+      },
+      onDataPart(value) {
+        data.push(...value);
+        execUpdate();
+      },
+      onMessageAnnotationsPart(value) {
+        if (messageAnnotations == null) {
+          messageAnnotations = [...value];
+        } else {
+          messageAnnotations.push(...value);
+        }
+        execUpdate();
+      },
+      onFinishStepPart(value) {
+        step += 1;
+        currentTextPart = value.isContinued ? currentTextPart : void 0;
+        currentReasoningPart = void 0;
+        currentReasoningTextDetail = void 0;
+      },
+      onStartStepPart(value) {
+        if (!replaceLastMessage) {
+          message.id = value.messageId;
+        }
+        message.parts.push({ type: "step-start" });
+        execUpdate();
+      },
+      onFinishMessagePart(value) {
+        finishReason = value.finishReason;
+        if (value.usage != null) {
+          usage = value.usage;
+        }
+      },
+      onErrorPart(error) {
+        throw new Error(error);
+      }
     });
+    onFinish?.({ message, finishReason, usage });
   }
   /**
    * 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) {
+  async streamLegacy(params) {
     const processedParams = {
       ...params,
-      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
-      experimental_output: params.experimental_output instanceof ZodSchema ? 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: parseClientRuntimeContext(params.runtimeContext),
+      clientTools: processClientTools(params.clientTools)
+    };
+    const { readable, writable } = new TransformStream();
+    const response = await this.processStreamResponseLegacy(processedParams, writable);
+    const streamResponse = new Response(readable, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    streamResponse.processDataStream = async (options = {}) => {
+      await processDataStream({
+        stream: streamResponse.body,
+        ...options
+      });
     };
-    const response = await this.request(`/api/agents/${this.agentId}/stream`, {
+    return streamResponse;
+  }
+  async processChatResponse_vNext({
+    stream,
+    update,
+    onToolCall,
+    onFinish,
+    getCurrentDate = () => /* @__PURE__ */ new Date(),
+    lastMessage
+  }) {
+    const replaceLastMessage = lastMessage?.role === "assistant";
+    let step = replaceLastMessage ? 1 + // find max step in existing tool invocations:
+    (lastMessage.toolInvocations?.reduce((max, toolInvocation) => {
+      return Math.max(max, toolInvocation.step ?? 0);
+    }, 0) ?? 0) : 0;
+    const message = replaceLastMessage ? structuredClone(lastMessage) : {
+      id: v4(),
+      createdAt: getCurrentDate(),
+      role: "assistant",
+      content: "",
+      parts: []
+    };
+    let currentTextPart = void 0;
+    let currentReasoningPart = void 0;
+    let currentReasoningTextDetail = void 0;
+    function updateToolInvocationPart(toolCallId, invocation) {
+      const part = message.parts.find(
+        (part2) => part2.type === "tool-invocation" && part2.toolInvocation.toolCallId === toolCallId
+      );
+      if (part != null) {
+        part.toolInvocation = invocation;
+      } else {
+        message.parts.push({
+          type: "tool-invocation",
+          toolInvocation: invocation
+        });
+      }
+    }
+    const data = [];
+    let messageAnnotations = replaceLastMessage ? lastMessage?.annotations : void 0;
+    const partialToolCalls = {};
+    let usage = {
+      completionTokens: NaN,
+      promptTokens: NaN,
+      totalTokens: NaN
+    };
+    let finishReason = "unknown";
+    function execUpdate() {
+      const copiedData = [...data];
+      if (messageAnnotations?.length) {
+        message.annotations = messageAnnotations;
+      }
+      const copiedMessage = {
+        // deep copy the message to ensure that deep changes (msg attachments) are updated
+        // with SolidJS. SolidJS uses referential integration of sub-objects to detect changes.
+        ...structuredClone(message),
+        // add a revision id to ensure that the message is updated with SWR. SWR uses a
+        // hashing approach by default to detect changes, but it only works for shallow
+        // changes. This is why we need to add a revision id to ensure that the message
+        // is updated with SWR (without it, the changes get stuck in SWR and are not
+        // forwarded to rendering):
+        revisionId: v4()
+      };
+      update({
+        message: copiedMessage,
+        data: copiedData,
+        replaceLastMessage
+      });
+    }
+    await processMastraStream({
+      stream,
+      // TODO: casting as any here because the stream types were all typed as any before in core.
+      // but this is completely wrong and this fn is probably broken. Remove ":any" and you'll see a bunch of type errors
+      onChunk: async (chunk) => {
+        switch (chunk.type) {
+          case "tripwire": {
+            message.parts.push({
+              type: "text",
+              text: chunk.payload.tripwireReason
+            });
+            execUpdate();
+            break;
+          }
+          case "step-start": {
+            if (!replaceLastMessage) {
+              message.id = chunk.payload.messageId;
+            }
+            message.parts.push({ type: "step-start" });
+            execUpdate();
+            break;
+          }
+          case "text-delta": {
+            if (currentTextPart == null) {
+              currentTextPart = {
+                type: "text",
+                text: chunk.payload.text
+              };
+              message.parts.push(currentTextPart);
+            } else {
+              currentTextPart.text += chunk.payload.text;
+            }
+            message.content += chunk.payload.text;
+            execUpdate();
+            break;
+          }
+          case "reasoning-delta": {
+            if (currentReasoningTextDetail == null) {
+              currentReasoningTextDetail = { type: "text", text: chunk.payload.text };
+              if (currentReasoningPart != null) {
+                currentReasoningPart.details.push(currentReasoningTextDetail);
+              }
+            } else {
+              currentReasoningTextDetail.text += chunk.payload.text;
+            }
+            if (currentReasoningPart == null) {
+              currentReasoningPart = {
+                type: "reasoning",
+                reasoning: chunk.payload.text,
+                details: [currentReasoningTextDetail]
+              };
+              message.parts.push(currentReasoningPart);
+            } else {
+              currentReasoningPart.reasoning += chunk.payload.text;
+            }
+            message.reasoning = (message.reasoning ?? "") + chunk.payload.text;
+            execUpdate();
+            break;
+          }
+          case "file": {
+            message.parts.push({
+              type: "file",
+              mimeType: chunk.payload.mimeType,
+              data: chunk.payload.data
+            });
+            execUpdate();
+            break;
+          }
+          case "source": {
+            message.parts.push({
+              type: "source",
+              source: chunk.payload.source
+            });
+            execUpdate();
+            break;
+          }
+          case "tool-call": {
+            const invocation = {
+              state: "call",
+              step,
+              ...chunk.payload
+            };
+            if (partialToolCalls[chunk.payload.toolCallId] != null) {
+              message.toolInvocations[partialToolCalls[chunk.payload.toolCallId].index] = invocation;
+            } else {
+              if (message.toolInvocations == null) {
+                message.toolInvocations = [];
+              }
+              message.toolInvocations.push(invocation);
+            }
+            updateToolInvocationPart(chunk.payload.toolCallId, invocation);
+            execUpdate();
+            if (onToolCall) {
+              const result = await onToolCall({ toolCall: chunk.payload });
+              if (result != null) {
+                const invocation2 = {
+                  state: "result",
+                  step,
+                  ...chunk.payload,
+                  result
+                };
+                message.toolInvocations[message.toolInvocations.length - 1] = invocation2;
+                updateToolInvocationPart(chunk.payload.toolCallId, invocation2);
+                execUpdate();
+              }
+            }
+          }
+          case "tool-call-input-streaming-start": {
+            if (message.toolInvocations == null) {
+              message.toolInvocations = [];
+            }
+            partialToolCalls[chunk.payload.toolCallId] = {
+              text: "",
+              step,
+              toolName: chunk.payload.toolName,
+              index: message.toolInvocations.length
+            };
+            const invocation = {
+              state: "partial-call",
+              step,
+              toolCallId: chunk.payload.toolCallId,
+              toolName: chunk.payload.toolName,
+              args: chunk.payload.args
+            };
+            message.toolInvocations.push(invocation);
+            updateToolInvocationPart(chunk.payload.toolCallId, invocation);
+            execUpdate();
+            break;
+          }
+          case "tool-call-delta": {
+            const partialToolCall = partialToolCalls[chunk.payload.toolCallId];
+            partialToolCall.text += chunk.payload.argsTextDelta;
+            const { value: partialArgs } = parsePartialJson(partialToolCall.text);
+            const invocation = {
+              state: "partial-call",
+              step: partialToolCall.step,
+              toolCallId: chunk.payload.toolCallId,
+              toolName: partialToolCall.toolName,
+              args: partialArgs
+            };
+            message.toolInvocations[partialToolCall.index] = invocation;
+            updateToolInvocationPart(chunk.payload.toolCallId, invocation);
+            execUpdate();
+            break;
+          }
+          case "tool-result": {
+            const toolInvocations = message.toolInvocations;
+            if (toolInvocations == null) {
+              throw new Error("tool_result must be preceded by a tool_call");
+            }
+            const toolInvocationIndex = toolInvocations.findIndex(
+              (invocation2) => invocation2.toolCallId === chunk.payload.toolCallId
+            );
+            if (toolInvocationIndex === -1) {
+              throw new Error("tool_result must be preceded by a tool_call with the same toolCallId");
+            }
+            const invocation = {
+              ...toolInvocations[toolInvocationIndex],
+              state: "result",
+              ...chunk.payload
+            };
+            toolInvocations[toolInvocationIndex] = invocation;
+            updateToolInvocationPart(chunk.payload.toolCallId, invocation);
+            execUpdate();
+            break;
+          }
+          case "error": {
+            throw getErrorFromUnknown(chunk.payload.error, {
+              fallbackMessage: "Unknown error in stream",
+              supportSerialization: false
+            });
+          }
+          case "data": {
+            data.push(...chunk.payload.data);
+            execUpdate();
+            break;
+          }
+          case "step-finish": {
+            step += 1;
+            currentTextPart = chunk.payload.stepResult.isContinued ? currentTextPart : void 0;
+            currentReasoningPart = void 0;
+            currentReasoningTextDetail = void 0;
+            execUpdate();
+            break;
+          }
+          case "finish": {
+            finishReason = chunk.payload.stepResult.reason;
+            if (chunk.payload.usage != null) {
+              usage = chunk.payload.usage;
+            }
+            break;
+          }
+        }
+      }
+    });
+    onFinish?.({ message, finishReason, usage });
+  }
+  async processStreamResponse(processedParams, writable, route = "stream") {
+    const response = await this.request(`/api/agents/${this.agentId}/${route}`, {
       method: "POST",
       body: processedParams,
       stream: true
@@ -160,91 +994,411 @@ var Agent = class extends BaseResource {
     if (!response.body) {
       throw new Error("No response body");
     }
-    response.processDataStream = async (options = {}) => {
-      await processDataStream({
-        stream: response.body,
+    try {
+      let toolCalls = [];
+      let messages = [];
+      const [streamForWritable, streamForProcessing] = response.body.tee();
+      streamForWritable.pipeTo(
+        new WritableStream({
+          async write(chunk) {
+            let writer;
+            try {
+              writer = writable.getWriter();
+              const text = new TextDecoder().decode(chunk);
+              const lines = text.split("\n\n");
+              const readableLines = lines.filter((line) => line !== "[DONE]").join("\n\n");
+              await writer.write(new TextEncoder().encode(readableLines));
+            } catch {
+              await writer?.write(chunk);
+            } finally {
+              writer?.releaseLock();
+            }
+          }
+        }),
+        {
+          preventClose: true
+        }
+      ).catch((error) => {
+        console.error("Error piping to writable stream:", error);
+      });
+      this.processChatResponse_vNext({
+        stream: streamForProcessing,
+        update: ({ message }) => {
+          const existingIndex = messages.findIndex((m) => m.id === message.id);
+          if (existingIndex !== -1) {
+            messages[existingIndex] = message;
+          } else {
+            messages.push(message);
+          }
+        },
+        onFinish: async ({ finishReason, message }) => {
+          if (finishReason === "tool-calls") {
+            const toolCall = [...message?.parts ?? []].reverse().find((part) => part.type === "tool-invocation")?.toolInvocation;
+            if (toolCall) {
+              toolCalls.push(toolCall);
+            }
+            let shouldExecuteClientTool = false;
+            for (const toolCall2 of toolCalls) {
+              const clientTool = processedParams.clientTools?.[toolCall2.toolName];
+              if (clientTool && clientTool.execute) {
+                shouldExecuteClientTool = true;
+                const result = await clientTool.execute(
+                  {
+                    context: toolCall2?.args,
+                    runId: processedParams.runId,
+                    resourceId: processedParams.resourceId,
+                    threadId: processedParams.threadId,
+                    runtimeContext: processedParams.runtimeContext,
+                    // TODO: Pass proper tracing context when client-js supports tracing
+                    tracingContext: { currentSpan: void 0 },
+                    suspend: async () => {
+                    }
+                  },
+                  {
+                    messages: response.messages,
+                    toolCallId: toolCall2?.toolCallId
+                  }
+                );
+                const lastMessageRaw = messages[messages.length - 1];
+                const lastMessage = lastMessageRaw != null ? JSON.parse(JSON.stringify(lastMessageRaw)) : void 0;
+                const toolInvocationPart = lastMessage?.parts?.find(
+                  (part) => part.type === "tool-invocation" && part.toolInvocation?.toolCallId === toolCall2.toolCallId
+                );
+                if (toolInvocationPart) {
+                  toolInvocationPart.toolInvocation = {
+                    ...toolInvocationPart.toolInvocation,
+                    state: "result",
+                    result
+                  };
+                }
+                const toolInvocation = lastMessage?.toolInvocations?.find(
+                  (toolInvocation2) => toolInvocation2.toolCallId === toolCall2.toolCallId
+                );
+                if (toolInvocation) {
+                  toolInvocation.state = "result";
+                  toolInvocation.result = result;
+                }
+                const updatedMessages = lastMessage != null ? [...messages.filter((m) => m.id !== lastMessage.id), lastMessage] : [...messages];
+                this.processStreamResponse(
+                  {
+                    ...processedParams,
+                    messages: updatedMessages
+                  },
+                  writable
+                ).catch((error) => {
+                  console.error("Error processing stream response:", error);
+                });
+              }
+            }
+            if (!shouldExecuteClientTool) {
+              setTimeout(() => {
+                writable.close();
+              }, 0);
+            }
+          } else {
+            setTimeout(() => {
+              writable.close();
+            }, 0);
+          }
+        },
+        lastMessage: void 0
+      }).catch((error) => {
+        console.error("Error processing stream response:", error);
+      });
+    } catch (error) {
+      console.error("Error processing stream response:", error);
+    }
+    return response;
+  }
+  async network(params) {
+    const response = await this.request(`/api/agents/${this.agentId}/network`, {
+      method: "POST",
+      body: params,
+      stream: true
+    });
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    const streamResponse = new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    streamResponse.processDataStream = async ({
+      onChunk
+    }) => {
+      await processMastraNetworkStream({
+        stream: streamResponse.body,
+        onChunk
+      });
+    };
+    return streamResponse;
+  }
+  async stream(messagesOrParams, options) {
+    let params;
+    if (typeof messagesOrParams === "object" && "messages" in messagesOrParams) {
+      params = messagesOrParams;
+    } else {
+      params = {
+        messages: messagesOrParams,
         ...options
+      };
+    }
+    const processedParams = {
+      ...params,
+      runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      clientTools: processClientTools(params.clientTools),
+      structuredOutput: params.structuredOutput ? {
+        ...params.structuredOutput,
+        schema: zodToJsonSchema(params.structuredOutput.schema)
+      } : void 0
+    };
+    const { readable, writable } = new TransformStream();
+    const response = await this.processStreamResponse(processedParams, writable);
+    const streamResponse = new Response(readable, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    streamResponse.processDataStream = async ({
+      onChunk
+    }) => {
+      await processMastraStream({
+        stream: streamResponse.body,
+        onChunk
+      });
+    };
+    return streamResponse;
+  }
+  async approveToolCall(params) {
+    const { readable, writable } = new TransformStream();
+    const response = await this.processStreamResponse(params, writable, "approve-tool-call");
+    const streamResponse = new Response(readable, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    streamResponse.processDataStream = async ({
+      onChunk
+    }) => {
+      await processMastraStream({
+        stream: streamResponse.body,
+        onChunk
       });
     };
+    return streamResponse;
+  }
+  async declineToolCall(params) {
+    const { readable, writable } = new TransformStream();
+    const response = await this.processStreamResponse(params, writable, "decline-tool-call");
+    const streamResponse = new Response(readable, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    streamResponse.processDataStream = async ({
+      onChunk
+    }) => {
+      await processMastraStream({
+        stream: streamResponse.body,
+        onChunk
+      });
+    };
+    return streamResponse;
+  }
+  /**
+   * Processes the stream response and handles tool calls
+   */
+  async processStreamResponseLegacy(processedParams, writable) {
+    const response = await this.request(`/api/agents/${this.agentId}/stream-legacy`, {
+      method: "POST",
+      body: processedParams,
+      stream: true
+    });
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    try {
+      let toolCalls = [];
+      let messages = [];
+      const [streamForWritable, streamForProcessing] = response.body.tee();
+      streamForWritable.pipeTo(writable, {
+        preventClose: true
+      }).catch((error) => {
+        console.error("Error piping to writable stream:", error);
+      });
+      this.processChatResponse({
+        stream: streamForProcessing,
+        update: ({ message }) => {
+          const existingIndex = messages.findIndex((m) => m.id === message.id);
+          if (existingIndex !== -1) {
+            messages[existingIndex] = message;
+          } else {
+            messages.push(message);
+          }
+        },
+        onFinish: async ({ finishReason, message }) => {
+          if (finishReason === "tool-calls") {
+            const toolCall = [...message?.parts ?? []].reverse().find((part) => part.type === "tool-invocation")?.toolInvocation;
+            if (toolCall) {
+              toolCalls.push(toolCall);
+            }
+            for (const toolCall2 of toolCalls) {
+              const clientTool = processedParams.clientTools?.[toolCall2.toolName];
+              if (clientTool && clientTool.execute) {
+                const result = await clientTool.execute(
+                  {
+                    context: toolCall2?.args,
+                    runId: processedParams.runId,
+                    resourceId: processedParams.resourceId,
+                    threadId: processedParams.threadId,
+                    runtimeContext: processedParams.runtimeContext,
+                    // TODO: Pass proper tracing context when client-js supports tracing
+                    tracingContext: { currentSpan: void 0 },
+                    suspend: async () => {
+                    }
+                  },
+                  {
+                    messages: response.messages,
+                    toolCallId: toolCall2?.toolCallId
+                  }
+                );
+                const lastMessage = JSON.parse(JSON.stringify(messages[messages.length - 1]));
+                const toolInvocationPart = lastMessage?.parts?.find(
+                  (part) => part.type === "tool-invocation" && part.toolInvocation?.toolCallId === toolCall2.toolCallId
+                );
+                if (toolInvocationPart) {
+                  toolInvocationPart.toolInvocation = {
+                    ...toolInvocationPart.toolInvocation,
+                    state: "result",
+                    result
+                  };
+                }
+                const toolInvocation = lastMessage?.toolInvocations?.find(
+                  (toolInvocation2) => toolInvocation2.toolCallId === toolCall2.toolCallId
+                );
+                if (toolInvocation) {
+                  toolInvocation.state = "result";
+                  toolInvocation.result = result;
+                }
+                const writer = writable.getWriter();
+                try {
+                  await writer.write(
+                    new TextEncoder().encode(
+                      "a:" + JSON.stringify({
+                        toolCallId: toolCall2.toolCallId,
+                        result
+                      }) + "\n"
+                    )
+                  );
+                } finally {
+                  writer.releaseLock();
+                }
+                this.processStreamResponseLegacy(
+                  {
+                    ...processedParams,
+                    messages: [...messages.filter((m) => m.id !== lastMessage.id), lastMessage]
+                  },
+                  writable
+                ).catch((error) => {
+                  console.error("Error processing stream response:", error);
+                });
+              }
+            }
+          } else {
+            setTimeout(() => {
+              writable.close();
+            }, 0);
+          }
+        },
+        lastMessage: void 0
+      }).catch((error) => {
+        console.error("Error processing stream response:", error);
+      });
+    } catch (error) {
+      console.error("Error processing stream response:", error);
+    }
     return response;
   }
   /**
    * Gets details about a specific tool available to the agent
    * @param toolId - ID of the tool to retrieve
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing tool details
    */
-  getTool(toolId) {
-    return this.request(`/api/agents/${this.agentId}/tools/${toolId}`);
+  getTool(toolId, runtimeContext) {
+    return this.request(`/api/agents/${this.agentId}/tools/${toolId}${runtimeContextQueryString(runtimeContext)}`);
+  }
+  /**
+   * 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: parseClientRuntimeContext(params.runtimeContext)
+    };
+    return this.request(`/api/agents/${this.agentId}/tools/${toolId}/execute`, {
+      method: "POST",
+      body
+    });
   }
   /**
    * Retrieves evaluation results for the agent
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing agent evaluations
    */
-  evals() {
-    return this.request(`/api/agents/${this.agentId}/evals/ci`);
+  evals(runtimeContext) {
+    return this.request(`/api/agents/${this.agentId}/evals/ci${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
    * Retrieves live evaluation results for the agent
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing live agent evaluations
    */
-  liveEvals() {
-    return this.request(`/api/agents/${this.agentId}/evals/live`);
-  }
-};
-var Network = class extends BaseResource {
-  constructor(options, networkId) {
-    super(options);
-    this.networkId = networkId;
+  liveEvals(runtimeContext) {
+    return this.request(`/api/agents/${this.agentId}/evals/live${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
-   * Retrieves details about the network
-   * @returns Promise containing network details
+   * Updates the model for the agent
+   * @param params - Parameters for updating the model
+   * @returns Promise containing the updated model
    */
-  details() {
-    return this.request(`/api/networks/${this.networkId}`);
+  updateModel(params) {
+    return this.request(`/api/agents/${this.agentId}/model`, {
+      method: "POST",
+      body: params
+    });
   }
   /**
-   * Generates a response from the agent
-   * @param params - Generation parameters including prompt
-   * @returns Promise containing the generated response
+   * Updates the model for the agent in the model list
+   * @param params - Parameters for updating the model
+   * @returns Promise containing the updated model
    */
-  generate(params) {
-    const processedParams = {
-      ...params,
-      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
-      experimental_output: params.experimental_output instanceof ZodSchema ? zodToJsonSchema(params.experimental_output) : params.experimental_output
-    };
-    return this.request(`/api/networks/${this.networkId}/generate`, {
+  updateModelInModelList({ modelConfigId, ...params }) {
+    return this.request(`/api/agents/${this.agentId}/models/${modelConfigId}`, {
       method: "POST",
-      body: processedParams
+      body: params
     });
   }
   /**
-   * Streams a response from the agent
-   * @param params - Stream parameters including prompt
-   * @returns Promise containing the enhanced Response object with processDataStream method
+   * Reorders the models for the agent
+   * @param params - Parameters for reordering the model list
+   * @returns Promise containing the updated model list
    */
-  async stream(params) {
-    const processedParams = {
-      ...params,
-      output: params.output instanceof ZodSchema ? zodToJsonSchema(params.output) : params.output,
-      experimental_output: params.experimental_output instanceof ZodSchema ? zodToJsonSchema(params.experimental_output) : params.experimental_output
-    };
-    const response = await this.request(`/api/networks/${this.networkId}/stream`, {
+  reorderModelList(params) {
+    return this.request(`/api/agents/${this.agentId}/models/reorder`, {
       method: "POST",
-      body: processedParams,
-      stream: true
+      body: params
     });
-    if (!response.body) {
-      throw new Error("No response body");
-    }
-    response.processDataStream = async (options = {}) => {
-      await processDataStream({
-        stream: response.body,
-        ...options
-      });
-    };
-    return response;
+  }
+  async generateVNext(_messagesOrParams, _options) {
+    throw new Error("generateVNext has been renamed to generate. Please use generate instead.");
+  }
+  async streamVNext(_messagesOrParams, _options) {
+    throw new Error("streamVNext has been renamed to stream. Please use stream instead.");
   }
 };
 
@@ -257,37 +1411,91 @@ var MemoryThread = class extends BaseResource {
   }
   /**
    * Retrieves the memory thread details
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing thread details including title and metadata
    */
-  get() {
-    return this.request(`/api/memory/threads/${this.threadId}?agentId=${this.agentId}`);
+  get(runtimeContext) {
+    return this.request(
+      `/api/memory/threads/${this.threadId}?agentId=${this.agentId}${runtimeContextQueryString(runtimeContext, "&")}`
+    );
   }
   /**
    * Updates the memory thread properties
-   * @param params - Update parameters including title and metadata
+   * @param params - Update parameters including title, metadata, and optional runtime context
    * @returns Promise containing updated thread details
    */
   update(params) {
-    return this.request(`/api/memory/threads/${this.threadId}?agentId=${this.agentId}`, {
-      method: "PATCH",
-      body: params
-    });
+    return this.request(
+      `/api/memory/threads/${this.threadId}?agentId=${this.agentId}${runtimeContextQueryString(params.runtimeContext, "&")}`,
+      {
+        method: "PATCH",
+        body: params
+      }
+    );
   }
   /**
    * Deletes the memory thread
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing deletion result
    */
-  delete() {
-    return this.request(`/api/memory/threads/${this.threadId}?agentId=${this.agentId}`, {
-      method: "DELETE"
-    });
+  delete(runtimeContext) {
+    return this.request(
+      `/api/memory/threads/${this.threadId}?agentId=${this.agentId}${runtimeContextQueryString(runtimeContext, "&")}`,
+      {
+        method: "DELETE"
+      }
+    );
   }
   /**
    * Retrieves messages associated with the thread
+   * @param params - Optional parameters including limit for number of messages to retrieve and runtime context
    * @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()}${runtimeContextQueryString(params?.runtimeContext, "&")}`
+    );
+  }
+  /**
+   * Retrieves paginated messages associated with the thread with advanced filtering and selection options
+   * @param params - Pagination parameters including selectBy criteria, page, perPage, date ranges, message inclusion options, and runtime context
+   * @returns Promise containing paginated thread messages with pagination metadata (total, page, perPage, hasMore)
+   */
+  getMessagesPaginated({
+    selectBy,
+    runtimeContext,
+    ...rest
+  }) {
+    const query = new URLSearchParams({
+      ...rest,
+      ...selectBy ? { selectBy: JSON.stringify(selectBy) } : {}
+    });
+    return this.request(
+      `/api/memory/threads/${this.threadId}/messages/paginated?${query.toString()}${runtimeContextQueryString(runtimeContext, "&")}`
+    );
+  }
+  /**
+   * Deletes one or more messages from the thread
+   * @param messageIds - Can be a single message ID (string), array of message IDs,
+   *                     message object with id property, or array of message objects
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @returns Promise containing deletion result
+   */
+  deleteMessages(messageIds, runtimeContext) {
+    const query = new URLSearchParams({
+      agentId: this.agentId
+    });
+    return this.request(
+      `/api/memory/messages/delete?${query.toString()}${runtimeContextQueryString(runtimeContext, "&")}`,
+      {
+        method: "POST",
+        body: { messageIds }
+      }
+    );
   }
 };
 
@@ -300,10 +1508,13 @@ var Vector = class extends BaseResource {
   /**
    * Retrieves details about a specific vector index
    * @param indexName - Name of the index to get details for
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing vector index details
    */
-  details(indexName) {
-    return this.request(`/api/vector/${this.vectorName}/indexes/${indexName}`);
+  details(indexName, runtimeContext) {
+    return this.request(
+      `/api/vector/${this.vectorName}/indexes/${indexName}${runtimeContextQueryString(runtimeContext)}`
+    );
   }
   /**
    * Deletes a vector index
@@ -317,10 +1528,11 @@ var Vector = class extends BaseResource {
   }
   /**
    * Retrieves a list of all available indexes
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing array of index names
    */
-  getIndexes() {
-    return this.request(`/api/vector/${this.vectorName}/indexes`);
+  getIndexes(runtimeContext) {
+    return this.request(`/api/vector/${this.vectorName}/indexes${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
    * Creates a new vector index
@@ -357,107 +1569,50 @@ var Vector = class extends BaseResource {
   }
 };
 
-// src/resources/workflow.ts
-var RECORD_SEPARATOR = "";
-var Workflow = class extends BaseResource {
-  constructor(options, workflowId) {
+// src/resources/tool.ts
+var Tool = class extends BaseResource {
+  constructor(options, toolId) {
     super(options);
-    this.workflowId = workflowId;
+    this.toolId = toolId;
   }
   /**
-   * Retrieves details about the workflow
-   * @returns Promise containing workflow details including steps and graphs
+   * Retrieves details about the tool
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @returns Promise containing tool details including description and schemas
    */
-  details() {
-    return this.request(`/api/workflows/${this.workflowId}`);
+  details(runtimeContext) {
+    return this.request(`/api/tools/${this.toolId}${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
-   * @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
+   * Executes the tool with the provided parameters
+   * @param params - Parameters required for tool execution
+   * @returns Promise containing the tool execution results
    */
   execute(params) {
-    return this.request(`/api/workflows/${this.workflowId}/execute`, {
-      method: "POST",
-      body: params
-    });
-  }
-  /**
-   * 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
-   * @returns Promise containing the workflow resume results
-   */
-  resume({
-    stepId,
-    runId,
-    context
-  }) {
-    return this.request(`/api/workflows/${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) {
-    const searchParams = new URLSearchParams();
-    if (!!params?.runId) {
-      searchParams.set("runId", params.runId);
+    const url = new URLSearchParams();
+    if (params.runId) {
+      url.set("runId", params.runId);
     }
-    return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
+    const body = {
+      data: params.data,
+      runtimeContext: parseClientRuntimeContext(params.runtimeContext)
+    };
+    return this.request(`/api/tools/${this.toolId}/execute?${url.toString()}`, {
       method: "POST",
-      body: params?.triggerData
+      body
     });
   }
-  /**
-   * 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
-      }
-    });
+};
+
+// src/resources/workflow.ts
+var RECORD_SEPARATOR = "";
+var Workflow = class extends BaseResource {
+  constructor(options, workflowId) {
+    super(options);
+    this.workflowId = workflowId;
   }
   /**
-   * Creates an async generator that processes a readable stream and yields 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
@@ -487,7 +1642,7 @@ var Workflow = class extends BaseResource {
               }
             }
           }
-        } catch (error) {
+        } catch {
         }
       }
       if (buffer) {
@@ -502,135 +1657,1411 @@ var Workflow = class extends BaseResource {
     }
   }
   /**
-   * Watches 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
+   * Retrieves details about the workflow
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @returns Promise containing workflow details including steps and graphs
    */
-  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}`);
+  details(runtimeContext) {
+    return this.request(`/api/workflows/${this.workflowId}${runtimeContextQueryString(runtimeContext)}`);
+  }
+  /**
+   * Retrieves all runs for a workflow
+   * @param params - Parameters for filtering runs
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @returns Promise containing workflow runs array
+   */
+  runs(params, runtimeContext) {
+    const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
+    const searchParams = new URLSearchParams();
+    if (params?.fromDate) {
+      searchParams.set("fromDate", params.fromDate.toISOString());
     }
-    if (!response.body) {
-      throw new Error("Response body is null");
+    if (params?.toDate) {
+      searchParams.set("toDate", params.toDate.toISOString());
     }
-    for await (const record of this.streamProcessor(response.body)) {
-      onRecord(record);
+    if (params?.limit !== null && params?.limit !== void 0 && !isNaN(Number(params?.limit))) {
+      searchParams.set("limit", String(params.limit));
+    }
+    if (params?.offset !== null && params?.offset !== void 0 && !isNaN(Number(params?.offset))) {
+      searchParams.set("offset", String(params.offset));
+    }
+    if (params?.resourceId) {
+      searchParams.set("resourceId", params.resourceId);
+    }
+    if (runtimeContextParam) {
+      searchParams.set("runtimeContext", runtimeContextParam);
+    }
+    if (searchParams.size) {
+      return this.request(`/api/workflows/${this.workflowId}/runs?${searchParams}`);
+    } else {
+      return this.request(`/api/workflows/${this.workflowId}/runs`);
     }
-  }
-};
-
-// src/resources/tool.ts
-var Tool = class extends BaseResource {
-  constructor(options, toolId) {
-    super(options);
-    this.toolId = toolId;
   }
   /**
-   * Retrieves details about the tool
-   * @returns Promise containing tool details including description and schemas
+   * Retrieves a specific workflow run by its ID
+   * @param runId - The ID of the workflow run to retrieve
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @returns Promise containing the workflow run details
    */
-  details() {
-    return this.request(`/api/tools/${this.toolId}`);
+  runById(runId, runtimeContext) {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
-   * Executes the tool with the provided parameters
-   * @param params - Parameters required for tool execution
-   * @returns Promise containing the tool execution results
+   * Retrieves the execution result for a specific workflow run by its ID
+   * @param runId - The ID of the workflow run to retrieve the execution result for
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @returns Promise containing the workflow run execution result
    */
-  execute(params) {
-    return this.request(`/api/tools/${this.toolId}/execute`, {
-      method: "POST",
-      body: params
-    });
-  }
-};
-
-// src/client.ts
-var MastraClient = class extends BaseResource {
-  constructor(options) {
-    super(options);
+  runExecutionResult(runId, runtimeContext) {
+    return this.request(
+      `/api/workflows/${this.workflowId}/runs/${runId}/execution-result${runtimeContextQueryString(runtimeContext)}`
+    );
   }
   /**
-   * Retrieves all available agents
-   * @returns Promise containing map of agent IDs to agent details
+   * Cancels a specific workflow run by its ID
+   * @param runId - The ID of the workflow run to cancel
+   * @returns Promise containing a success message
    */
-  getAgents() {
-    return this.request("/api/agents");
+  cancelRun(runId) {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}/cancel`, {
+      method: "POST"
+    });
   }
   /**
-   * Gets an agent instance by ID
-   * @param agentId - ID of the agent to retrieve
-   * @returns Agent instance
+   * Sends an event to a specific workflow run by its ID
+   * @param params - Object containing the runId, event and data
+   * @returns Promise containing a success message
    */
-  getAgent(agentId) {
-    return new Agent(this.options, agentId);
+  sendRunEvent(params) {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${params.runId}/send-event`, {
+      method: "POST",
+      body: { event: params.event, data: params.data }
+    });
   }
   /**
-   * Retrieves memory threads for a resource
-   * @param params - Parameters containing the resource ID
-   * @returns Promise containing array of memory threads
+   * @deprecated Use createRunAsync() instead.
+   * @throws {Error} Always throws an error directing users to use createRunAsync()
    */
-  getMemoryThreads(params) {
-    return this.request(`/api/memory/threads?resourceid=${params.resourceId}&agentId=${params.agentId}`);
+  async createRun(_params) {
+    throw new Error(
+      "createRun() has been deprecated. Please use createRunAsync() instead.\n\nMigration guide:\n  Before: const run = workflow.createRun();\n  After:  const run = await workflow.createRunAsync();\n\nNote: createRunAsync() is an async method, so make sure your calling function is async."
+    );
   }
   /**
-   * Creates a new memory thread
-   * @param params - Parameters for creating the memory thread
-   * @returns Promise containing the created memory thread
+   * Creates a new workflow run
+   * @param params - Optional object containing the optional runId
+   * @returns Promise containing the runId of the created run with methods to control execution
    */
-  createMemoryThread(params) {
-    return this.request(`/api/memory/threads?agentId=${params.agentId}`, { method: "POST", body: params });
+  async createRunAsync(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    const res = await this.request(
+      `/api/workflows/${this.workflowId}/create-run?${searchParams.toString()}`,
+      {
+        method: "POST"
+      }
+    );
+    const runId = res.runId;
+    return {
+      runId,
+      start: async (p) => {
+        return this.start({
+          runId,
+          inputData: p.inputData,
+          runtimeContext: p.runtimeContext,
+          tracingOptions: p.tracingOptions
+        });
+      },
+      startAsync: async (p) => {
+        return this.startAsync({
+          runId,
+          inputData: p.inputData,
+          runtimeContext: p.runtimeContext,
+          tracingOptions: p.tracingOptions
+        });
+      },
+      watch: async (onRecord) => {
+        return this.watch({ runId }, onRecord);
+      },
+      stream: async (p) => {
+        return this.stream({ runId, inputData: p.inputData, runtimeContext: p.runtimeContext });
+      },
+      resume: async (p) => {
+        return this.resume({
+          runId,
+          step: p.step,
+          resumeData: p.resumeData,
+          runtimeContext: p.runtimeContext,
+          tracingOptions: p.tracingOptions
+        });
+      },
+      resumeAsync: async (p) => {
+        return this.resumeAsync({
+          runId,
+          step: p.step,
+          resumeData: p.resumeData,
+          runtimeContext: p.runtimeContext,
+          tracingOptions: p.tracingOptions
+        });
+      },
+      resumeStreamVNext: async (p) => {
+        return this.resumeStreamVNext({
+          runId,
+          step: p.step,
+          resumeData: p.resumeData,
+          runtimeContext: p.runtimeContext
+        });
+      }
+    };
   }
   /**
-   * Gets a memory thread instance by ID
-   * @param threadId - ID of the memory thread to retrieve
-   * @returns MemoryThread instance
+   * 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
    */
-  getMemoryThread(threadId, agentId) {
-    return new MemoryThread(this.options, threadId, agentId);
+  start(params) {
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    return this.request(`/api/workflows/${this.workflowId}/start?runId=${params.runId}`, {
+      method: "POST",
+      body: { inputData: params?.inputData, runtimeContext, tracingOptions: params.tracingOptions }
+    });
   }
   /**
-   * Saves messages to memory
-   * @param params - Parameters containing messages to save
-   * @returns Promise containing the saved messages
+   * 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
    */
-  saveMessageToMemory(params) {
-    return this.request(`/api/memory/save-messages?agentId=${params.agentId}`, {
+  resume({
+    step,
+    runId,
+    resumeData,
+    tracingOptions,
+    ...rest
+  }) {
+    const runtimeContext = parseClientRuntimeContext(rest.runtimeContext);
+    return this.request(`/api/workflows/${this.workflowId}/resume?runId=${runId}`, {
       method: "POST",
-      body: params
+      body: {
+        step,
+        resumeData,
+        runtimeContext,
+        tracingOptions
+      }
     });
   }
   /**
-   * Gets the status of the memory system
-   * @returns Promise containing memory system status
+   * 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 workflow execution results
    */
-  getMemoryStatus(agentId) {
-    return this.request(`/api/memory/status?agentId=${agentId}`);
+  startAsync(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
+      method: "POST",
+      body: { inputData: params.inputData, runtimeContext, tracingOptions: params.tracingOptions }
+    });
   }
   /**
-   * Retrieves all available tools
-   * @returns Promise containing map of tool IDs to tool details
+   * Starts a workflow run and returns a stream
+   * @param params - Object containing the optional runId, inputData and runtimeContext
+   * @returns Promise containing the workflow execution results
    */
-  getTools() {
-    return this.request("/api/tools");
+  async stream(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/stream?${searchParams.toString()}`,
+      {
+        method: "POST",
+        body: { inputData: params.inputData, runtimeContext, tracingOptions: params.tracingOptions },
+        stream: true
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to stream workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
   }
   /**
-   * Gets a tool instance by ID
-   * @param toolId - ID of the tool to retrieve
-   * @returns Tool instance
+   * Observes workflow stream for a workflow run
+   * @param params - Object containing the runId
+   * @returns Promise containing the workflow execution results
+   */
+  async observeStream(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/observe-stream?${searchParams.toString()}`,
+      {
+        method: "POST",
+        stream: true
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to observe workflow stream: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
+  /**
+   * Starts a workflow run and returns a stream
+   * @param params - Object containing the optional runId, inputData and runtimeContext
+   * @returns Promise containing the workflow execution results
+   */
+  async streamVNext(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/streamVNext?${searchParams.toString()}`,
+      {
+        method: "POST",
+        body: {
+          inputData: params.inputData,
+          runtimeContext,
+          closeOnSuspend: params.closeOnSuspend,
+          tracingOptions: params.tracingOptions
+        },
+        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");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
+  /**
+   * Observes workflow vNext stream for a workflow run
+   * @param params - Object containing the runId
+   * @returns Promise containing the workflow execution results
+   */
+  async observeStreamVNext(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/observe-streamVNext?${searchParams.toString()}`,
+      {
+        method: "POST",
+        stream: true
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to observe stream vNext workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
+  /**
+   * 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 workflow resume results
+   */
+  resumeAsync(params) {
+    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,
+        tracingOptions: params.tracingOptions
+      }
+    });
+  }
+  /**
+   * Resumes a suspended workflow step that uses streamVNext 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 workflow resume results
+   */
+  async resumeStreamVNext(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/resume-stream?${searchParams.toString()}`,
+      {
+        method: "POST",
+        body: {
+          step: params.step,
+          resumeData: params.resumeData,
+          runtimeContext,
+          tracingOptions: params.tracingOptions
+        },
+        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");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
+  /**
+   * Watches 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
+   */
+  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)) {
+      if (typeof record === "string") {
+        onRecord(JSON.parse(record));
+      } else {
+        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_SEPARATOR;
+            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-card.json`);
+  }
+  /**
+   * Send a message to the agent and gets a message or task response
+   * @param params - Parameters for the task
+   * @returns Promise containing the response
+   */
+  async sendMessage(params) {
+    const response = await this.request(`/a2a/${this.agentId}`, {
+      method: "POST",
+      body: {
+        method: "message/send",
+        params
+      }
+    });
+    return response;
+  }
+  /**
+   * Sends a message to an agent to initiate/continue a task and subscribes
+   * the client to real-time updates for that task via Server-Sent Events (SSE).
+   * @param params - Parameters for the task
+   * @returns A stream of Server-Sent Events. Each SSE `data` field contains a `SendStreamingMessageResponse`
+   */
+  async sendStreamingMessage(params) {
+    const response = await this.request(`/a2a/${this.agentId}`, {
+      method: "POST",
+      body: {
+        method: "message/stream",
+        params
+      }
+    });
+    return response;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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
+      }
+    });
+  }
+};
+
+// 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.
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @returns Promise containing the tool's information (name, description, schema).
+   */
+  details(runtimeContext) {
+    return this.request(`/api/mcp/${this.serverId}/tools/${this.toolId}${runtimeContextQueryString(runtimeContext)}`);
+  }
+  /**
+   * 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/resources/agent-builder.ts
+var RECORD_SEPARATOR2 = "";
+var AgentBuilder = class extends BaseResource {
+  constructor(options, actionId) {
+    super(options);
+    this.actionId = actionId;
+  }
+  // Helper function to transform workflow result to action result
+  transformWorkflowResult(result) {
+    if (result.status === "success") {
+      return {
+        success: result.result.success || false,
+        applied: result.result.applied || false,
+        branchName: result.result.branchName,
+        message: result.result.message || "Agent builder action completed",
+        validationResults: result.result.validationResults,
+        error: result.result.error,
+        errors: result.result.errors,
+        stepResults: result.result.stepResults
+      };
+    } else if (result.status === "failed") {
+      return {
+        success: false,
+        applied: false,
+        message: `Agent builder action failed: ${result.error.message}`,
+        error: result.error.message
+      };
+    } else {
+      return {
+        success: false,
+        applied: false,
+        message: "Agent builder action was suspended",
+        error: "Workflow suspended - manual intervention required"
+      };
+    }
+  }
+  /**
+   * Creates a transform stream that parses binary chunks into JSON records.
+   */
+  createRecordParserTransform() {
+    let failedChunk = void 0;
+    return 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) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+  }
+  /**
+   * @deprecated Use createRunAsync() instead.
+   * @throws {Error} Always throws an error directing users to use createRunAsync()
+   */
+  async createRun(_params) {
+    throw new Error(
+      "createRun() has been deprecated. Please use createRunAsync() instead.\n\nMigration guide:\n  Before: const run = agentBuilder.createRun();\n  After:  const run = await agentBuilder.createRunAsync();\n\nNote: createRunAsync() is an async method, so make sure your calling function is async."
+    );
+  }
+  /**
+   * Creates a new agent builder action run and returns the runId.
+   * This calls `/api/agent-builder/:actionId/create-run`.
+   */
+  async createRunAsync(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    const url = `/api/agent-builder/${this.actionId}/create-run${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
+    return this.request(url, {
+      method: "POST"
+    });
+  }
+  /**
+   * Starts agent builder action asynchronously and waits for completion.
+   * This calls `/api/agent-builder/:actionId/start-async`.
+   */
+  async startAsync(params, runId) {
+    const searchParams = new URLSearchParams();
+    if (runId) {
+      searchParams.set("runId", runId);
+    }
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const { runtimeContext: _, ...actionParams } = params;
+    const url = `/api/agent-builder/${this.actionId}/start-async${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
+    const result = await this.request(url, {
+      method: "POST",
+      body: { ...actionParams, runtimeContext }
+    });
+    return this.transformWorkflowResult(result);
+  }
+  /**
+   * Starts an existing agent builder action run.
+   * This calls `/api/agent-builder/:actionId/start`.
+   */
+  async startActionRun(params, runId) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", runId);
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const { runtimeContext: _, ...actionParams } = params;
+    const url = `/api/agent-builder/${this.actionId}/start?${searchParams.toString()}`;
+    return this.request(url, {
+      method: "POST",
+      body: { ...actionParams, runtimeContext }
+    });
+  }
+  /**
+   * Resumes a suspended agent builder action step.
+   * This calls `/api/agent-builder/:actionId/resume`.
+   */
+  async resume(params, runId) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", runId);
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const { runtimeContext: _, ...resumeParams } = params;
+    const url = `/api/agent-builder/${this.actionId}/resume?${searchParams.toString()}`;
+    return this.request(url, {
+      method: "POST",
+      body: { ...resumeParams, runtimeContext }
+    });
+  }
+  /**
+   * Resumes a suspended agent builder action step asynchronously.
+   * This calls `/api/agent-builder/:actionId/resume-async`.
+   */
+  async resumeAsync(params, runId) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", runId);
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const { runtimeContext: _, ...resumeParams } = params;
+    const url = `/api/agent-builder/${this.actionId}/resume-async?${searchParams.toString()}`;
+    const result = await this.request(url, {
+      method: "POST",
+      body: { ...resumeParams, runtimeContext }
+    });
+    return this.transformWorkflowResult(result);
+  }
+  /**
+   * Creates an async generator that processes a readable stream and yields action 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(() => {
+      });
+    }
+  }
+  /**
+   * Streams agent builder action progress in real-time.
+   * This calls `/api/agent-builder/:actionId/stream`.
+   */
+  async stream(params, runId) {
+    const searchParams = new URLSearchParams();
+    if (runId) {
+      searchParams.set("runId", runId);
+    }
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const { runtimeContext: _, ...actionParams } = params;
+    const url = `/api/agent-builder/${this.actionId}/stream${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
+    const response = await this.request(url, {
+      method: "POST",
+      body: { ...actionParams, runtimeContext },
+      stream: true
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to stream agent builder action: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    return response.body.pipeThrough(this.createRecordParserTransform());
+  }
+  /**
+   * Streams agent builder action progress in real-time using VNext streaming.
+   * This calls `/api/agent-builder/:actionId/streamVNext`.
+   */
+  async streamVNext(params, runId) {
+    const searchParams = new URLSearchParams();
+    if (runId) {
+      searchParams.set("runId", runId);
+    }
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const { runtimeContext: _, ...actionParams } = params;
+    const url = `/api/agent-builder/${this.actionId}/streamVNext${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
+    const response = await this.request(url, {
+      method: "POST",
+      body: { ...actionParams, runtimeContext },
+      stream: true
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to stream agent builder action VNext: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    return response.body.pipeThrough(this.createRecordParserTransform());
+  }
+  /**
+   * Watches an existing agent builder action run by runId.
+   * This is used for hot reload recovery - it loads the existing run state
+   * and streams any remaining progress.
+   * This calls `/api/agent-builder/:actionId/watch`.
+   */
+  async watch({ runId, eventType }, onRecord) {
+    const url = `/api/agent-builder/${this.actionId}/watch?runId=${runId}${eventType ? `&eventType=${eventType}` : ""}`;
+    const response = await this.request(url, {
+      method: "GET",
+      stream: true
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to watch agent builder action: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    for await (const record of this.streamProcessor(response.body)) {
+      if (typeof record === "string") {
+        onRecord(JSON.parse(record));
+      } else {
+        onRecord(record);
+      }
+    }
+  }
+  /**
+   * Observes an existing agent builder action run stream.
+   * Replays cached execution from the beginning, then continues with live stream.
+   * This is the recommended method for recovery after page refresh/hot reload.
+   * This calls `/api/agent-builder/:actionId/observe` (which delegates to observeStreamVNext).
+   */
+  async observeStream(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const url = `/api/agent-builder/${this.actionId}/observe?${searchParams.toString()}`;
+    const response = await this.request(url, {
+      method: "POST",
+      stream: true
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to observe agent builder action stream: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    return response.body.pipeThrough(this.createRecordParserTransform());
+  }
+  /**
+   * Observes an existing agent builder action run stream using VNext streaming API.
+   * Replays cached execution from the beginning, then continues with live stream.
+   * This calls `/api/agent-builder/:actionId/observe-streamVNext`.
+   */
+  async observeStreamVNext(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const url = `/api/agent-builder/${this.actionId}/observe-streamVNext?${searchParams.toString()}`;
+    const response = await this.request(url, {
+      method: "POST",
+      stream: true
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to observe agent builder action stream VNext: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    return response.body.pipeThrough(this.createRecordParserTransform());
+  }
+  /**
+   * Observes an existing agent builder action run stream using legacy streaming API.
+   * Replays cached execution from the beginning, then continues with live stream.
+   * This calls `/api/agent-builder/:actionId/observe-stream-legacy`.
+   */
+  async observeStreamLegacy(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const url = `/api/agent-builder/${this.actionId}/observe-stream-legacy?${searchParams.toString()}`;
+    const response = await this.request(url, {
+      method: "POST",
+      stream: true
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to observe agent builder action stream legacy: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    return response.body.pipeThrough(this.createRecordParserTransform());
+  }
+  /**
+   * Resumes a suspended agent builder action and streams the results.
+   * This calls `/api/agent-builder/:actionId/resume-stream`.
+   */
+  async resumeStream(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const { runId: _, runtimeContext: __, ...resumeParams } = params;
+    const url = `/api/agent-builder/${this.actionId}/resume-stream?${searchParams.toString()}`;
+    const response = await this.request(url, {
+      method: "POST",
+      body: { ...resumeParams, runtimeContext },
+      stream: true
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to resume agent builder action stream: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    return response.body.pipeThrough(this.createRecordParserTransform());
+  }
+  /**
+   * Gets a specific action run by its ID.
+   * This calls `/api/agent-builder/:actionId/runs/:runId`.
+   */
+  async runById(runId) {
+    const url = `/api/agent-builder/${this.actionId}/runs/${runId}`;
+    return this.request(url, {
+      method: "GET"
+    });
+  }
+  /**
+   * Gets details about this agent builder action.
+   * This calls `/api/agent-builder/:actionId`.
+   */
+  async details() {
+    const result = await this.request(`/api/agent-builder/${this.actionId}`);
+    return result;
+  }
+  /**
+   * Gets all runs for this agent builder action.
+   * This calls `/api/agent-builder/:actionId/runs`.
+   */
+  async 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 !== void 0) {
+      searchParams.set("limit", String(params.limit));
+    }
+    if (params?.offset !== void 0) {
+      searchParams.set("offset", String(params.offset));
+    }
+    if (params?.resourceId) {
+      searchParams.set("resourceId", params.resourceId);
+    }
+    const url = `/api/agent-builder/${this.actionId}/runs${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
+    return this.request(url, {
+      method: "GET"
+    });
+  }
+  /**
+   * Gets the execution result of an agent builder action run.
+   * This calls `/api/agent-builder/:actionId/runs/:runId/execution-result`.
+   */
+  async runExecutionResult(runId) {
+    const url = `/api/agent-builder/${this.actionId}/runs/${runId}/execution-result`;
+    return this.request(url, {
+      method: "GET"
+    });
+  }
+  /**
+   * Cancels an agent builder action run.
+   * This calls `/api/agent-builder/:actionId/runs/:runId/cancel`.
+   */
+  async cancelRun(runId) {
+    const url = `/api/agent-builder/${this.actionId}/runs/${runId}/cancel`;
+    return this.request(url, {
+      method: "POST"
+    });
+  }
+  /**
+   * Sends an event to an agent builder action run.
+   * This calls `/api/agent-builder/:actionId/runs/:runId/send-event`.
+   */
+  async sendRunEvent(params) {
+    const url = `/api/agent-builder/${this.actionId}/runs/${params.runId}/send-event`;
+    return this.request(url, {
+      method: "POST",
+      body: { event: params.event, data: params.data }
+    });
+  }
+};
+
+// src/resources/observability.ts
+var Observability = class extends BaseResource {
+  constructor(options) {
+    super(options);
+  }
+  /**
+   * Retrieves a specific AI trace by ID
+   * @param traceId - ID of the trace to retrieve
+   * @returns Promise containing the AI trace with all its spans
+   */
+  getTrace(traceId) {
+    return this.request(`/api/observability/traces/${traceId}`);
+  }
+  /**
+   * Retrieves paginated list of AI traces with optional filtering
+   * @param params - Parameters for pagination and filtering
+   * @returns Promise containing paginated traces and pagination info
+   */
+  getTraces(params) {
+    const { pagination, filters } = params;
+    const { page, perPage, dateRange } = pagination || {};
+    const { name, spanType, entityId, entityType } = filters || {};
+    const searchParams = new URLSearchParams();
+    if (page !== void 0) {
+      searchParams.set("page", String(page));
+    }
+    if (perPage !== void 0) {
+      searchParams.set("perPage", String(perPage));
+    }
+    if (name) {
+      searchParams.set("name", name);
+    }
+    if (spanType !== void 0) {
+      searchParams.set("spanType", String(spanType));
+    }
+    if (entityId && entityType) {
+      searchParams.set("entityId", entityId);
+      searchParams.set("entityType", entityType);
+    }
+    if (dateRange) {
+      const dateRangeStr = JSON.stringify({
+        start: dateRange.start instanceof Date ? dateRange.start.toISOString() : dateRange.start,
+        end: dateRange.end instanceof Date ? dateRange.end.toISOString() : dateRange.end
+      });
+      searchParams.set("dateRange", dateRangeStr);
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/observability/traces${queryString ? `?${queryString}` : ""}`);
+  }
+  /**
+   * Retrieves scores by trace ID and span ID
+   * @param params - Parameters containing trace ID, span ID, and pagination options
+   * @returns Promise containing scores and pagination info
+   */
+  getScoresBySpan(params) {
+    const { traceId, spanId, page, perPage } = params;
+    const searchParams = new URLSearchParams();
+    if (page !== void 0) {
+      searchParams.set("page", String(page));
+    }
+    if (perPage !== void 0) {
+      searchParams.set("perPage", String(perPage));
+    }
+    const queryString = searchParams.toString();
+    return this.request(
+      `/api/observability/traces/${encodeURIComponent(traceId)}/${encodeURIComponent(spanId)}/scores${queryString ? `?${queryString}` : ""}`
+    );
+  }
+  score(params) {
+    return this.request(`/api/observability/traces/score`, {
+      method: "POST",
+      body: { ...params }
+    });
+  }
+};
+
+// src/resources/network-memory-thread.ts
+var NetworkMemoryThread = class extends BaseResource {
+  constructor(options, threadId, networkId) {
+    super(options);
+    this.threadId = threadId;
+    this.networkId = networkId;
+  }
+  /**
+   * Retrieves the memory thread details
+   * @returns Promise containing thread details including title and metadata
+   */
+  get() {
+    return this.request(`/api/memory/network/threads/${this.threadId}?networkId=${this.networkId}`);
+  }
+  /**
+   * Updates the memory thread properties
+   * @param params - Update parameters including title and metadata
+   * @returns Promise containing updated thread details
+   */
+  update(params) {
+    return this.request(`/api/memory/network/threads/${this.threadId}?networkId=${this.networkId}`, {
+      method: "PATCH",
+      body: params
+    });
+  }
+  /**
+   * Deletes the memory thread
+   * @returns Promise containing deletion result
+   */
+  delete() {
+    return this.request(`/api/memory/network/threads/${this.threadId}?networkId=${this.networkId}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * 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(params) {
+    const query = new URLSearchParams({
+      networkId: this.networkId,
+      ...params?.limit ? { limit: params.limit.toString() } : {}
+    });
+    return this.request(`/api/memory/network/threads/${this.threadId}/messages?${query.toString()}`);
+  }
+  /**
+   * Deletes one or more messages from the thread
+   * @param messageIds - Can be a single message ID (string), array of message IDs,
+   *                     message object with id property, or array of message objects
+   * @returns Promise containing deletion result
+   */
+  deleteMessages(messageIds) {
+    const query = new URLSearchParams({
+      networkId: this.networkId
+    });
+    return this.request(`/api/memory/network/messages/delete?${query.toString()}`, {
+      method: "POST",
+      body: { messageIds }
+    });
+  }
+};
+
+// src/client.ts
+var MastraClient = class extends BaseResource {
+  observability;
+  constructor(options) {
+    super(options);
+    this.observability = new Observability(options);
+  }
+  /**
+   * Retrieves all available agents
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @returns Promise containing map of agent IDs to agent details
+   */
+  getAgents(runtimeContext) {
+    const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
+    const searchParams = new URLSearchParams();
+    if (runtimeContextParam) {
+      searchParams.set("runtimeContext", runtimeContextParam);
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/agents${queryString ? `?${queryString}` : ""}`);
+  }
+  getAgentsModelProviders() {
+    return this.request(`/api/agents/providers`);
+  }
+  /**
+   * Gets an agent instance by ID
+   * @param agentId - ID of the agent to retrieve
+   * @returns Agent instance
+   */
+  getAgent(agentId) {
+    return new Agent(this.options, agentId);
+  }
+  /**
+   * Retrieves memory threads for a resource
+   * @param params - Parameters containing the resource ID and optional runtime context
+   * @returns Promise containing array of memory threads
+   */
+  getMemoryThreads(params) {
+    return this.request(
+      `/api/memory/threads?resourceid=${params.resourceId}&agentId=${params.agentId}${runtimeContextQueryString(params.runtimeContext, "&")}`
+    );
+  }
+  /**
+   * Retrieves memory config for a resource
+   * @param params - Parameters containing the resource ID and optional runtime context
+   * @returns Promise containing memory configuration
+   */
+  getMemoryConfig(params) {
+    return this.request(
+      `/api/memory/config?agentId=${params.agentId}${runtimeContextQueryString(params.runtimeContext, "&")}`
+    );
+  }
+  /**
+   * Creates a new memory thread
+   * @param params - Parameters for creating the memory thread including optional runtime context
+   * @returns Promise containing the created memory thread
+   */
+  createMemoryThread(params) {
+    return this.request(
+      `/api/memory/threads?agentId=${params.agentId}${runtimeContextQueryString(params.runtimeContext, "&")}`,
+      { method: "POST", body: params }
+    );
+  }
+  /**
+   * Gets a memory thread instance by ID
+   * @param threadId - ID of the memory thread to retrieve
+   * @returns MemoryThread instance
+   */
+  getMemoryThread(threadId, agentId) {
+    return new MemoryThread(this.options, threadId, agentId);
+  }
+  getThreadMessages(threadId, opts = {}) {
+    let url = "";
+    if (opts.agentId) {
+      url = `/api/memory/threads/${threadId}/messages?agentId=${opts.agentId}${runtimeContextQueryString(opts.runtimeContext, "&")}`;
+    } else if (opts.networkId) {
+      url = `/api/memory/network/threads/${threadId}/messages?networkId=${opts.networkId}${runtimeContextQueryString(opts.runtimeContext, "&")}`;
+    }
+    return this.request(url);
+  }
+  deleteThread(threadId, opts = {}) {
+    let url = "";
+    if (opts.agentId) {
+      url = `/api/memory/threads/${threadId}?agentId=${opts.agentId}${runtimeContextQueryString(opts.runtimeContext, "&")}`;
+    } else if (opts.networkId) {
+      url = `/api/memory/network/threads/${threadId}?networkId=${opts.networkId}${runtimeContextQueryString(opts.runtimeContext, "&")}`;
+    }
+    return this.request(url, { method: "DELETE" });
+  }
+  /**
+   * Saves messages to memory
+   * @param params - Parameters containing messages to save and optional runtime context
+   * @returns Promise containing the saved messages
+   */
+  saveMessageToMemory(params) {
+    return this.request(
+      `/api/memory/save-messages?agentId=${params.agentId}${runtimeContextQueryString(params.runtimeContext, "&")}`,
+      {
+        method: "POST",
+        body: params
+      }
+    );
+  }
+  /**
+   * Gets the status of the memory system
+   * @param agentId - The agent ID
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @returns Promise containing memory system status
+   */
+  getMemoryStatus(agentId, runtimeContext) {
+    return this.request(`/api/memory/status?agentId=${agentId}${runtimeContextQueryString(runtimeContext, "&")}`);
+  }
+  /**
+   * Retrieves memory threads for a resource
+   * @param params - Parameters containing the resource ID
+   * @returns Promise containing array of memory threads
+   */
+  getNetworkMemoryThreads(params) {
+    return this.request(`/api/memory/network/threads?resourceid=${params.resourceId}&networkId=${params.networkId}`);
+  }
+  /**
+   * Creates a new memory thread
+   * @param params - Parameters for creating the memory thread
+   * @returns Promise containing the created memory thread
+   */
+  createNetworkMemoryThread(params) {
+    return this.request(`/api/memory/network/threads?networkId=${params.networkId}`, { method: "POST", body: params });
+  }
+  /**
+   * Gets a memory thread instance by ID
+   * @param threadId - ID of the memory thread to retrieve
+   * @returns MemoryThread instance
+   */
+  getNetworkMemoryThread(threadId, networkId) {
+    return new NetworkMemoryThread(this.options, threadId, networkId);
+  }
+  /**
+   * Saves messages to memory
+   * @param params - Parameters containing messages to save
+   * @returns Promise containing the saved messages
+   */
+  saveNetworkMessageToMemory(params) {
+    return this.request(`/api/memory/network/save-messages?networkId=${params.networkId}`, {
+      method: "POST",
+      body: params
+    });
+  }
+  /**
+   * Gets the status of the memory system
+   * @returns Promise containing memory system status
+   */
+  getNetworkMemoryStatus(networkId) {
+    return this.request(`/api/memory/network/status?networkId=${networkId}`);
+  }
+  /**
+   * Retrieves all available tools
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @returns Promise containing map of tool IDs to tool details
+   */
+  getTools(runtimeContext) {
+    const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
+    const searchParams = new URLSearchParams();
+    if (runtimeContextParam) {
+      searchParams.set("runtimeContext", runtimeContextParam);
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/tools${queryString ? `?${queryString}` : ""}`);
+  }
+  /**
+   * Gets a tool instance by ID
+   * @param toolId - ID of the tool to retrieve
+   * @returns Tool instance
    */
   getTool(toolId) {
     return new Tool(this.options, toolId);
   }
   /**
    * Retrieves all available workflows
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing map of workflow IDs to workflow details
    */
-  getWorkflows() {
-    return this.request("/api/workflows");
+  getWorkflows(runtimeContext) {
+    const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
+    const searchParams = new URLSearchParams();
+    if (runtimeContextParam) {
+      searchParams.set("runtimeContext", runtimeContextParam);
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/workflows${queryString ? `?${queryString}` : ""}`);
   }
   /**
    * Gets a workflow instance by ID
@@ -640,6 +3071,20 @@ var MastraClient = class extends BaseResource {
   getWorkflow(workflowId) {
     return new Workflow(this.options, workflowId);
   }
+  /**
+   * Gets all available agent builder actions
+   * @returns Promise containing map of action IDs to action details
+   */
+  getAgentBuilderActions() {
+    return this.request("/api/agent-builder/");
+  }
+  /**
+   * Gets an agent builder instance for executing agent-builder workflows
+   * @returns AgentBuilder instance
+   */
+  getAgentBuilderAction(actionId) {
+    return new AgentBuilder(this.options, actionId);
+  }
   /**
    * Gets a vector instance by name
    * @param vectorName - Name of the vector to retrieve
@@ -654,7 +3099,41 @@ var MastraClient = class extends BaseResource {
    * @returns Promise containing array of log messages
    */
   getLogs(params) {
-    return this.request(`/api/logs?transportId=${params.transportId}`);
+    const { transportId, fromDate, toDate, logLevel, filters, page, perPage } = params;
+    const _filters = filters ? Object.entries(filters).map(([key, value]) => `${key}:${value}`) : [];
+    const searchParams = new URLSearchParams();
+    if (transportId) {
+      searchParams.set("transportId", transportId);
+    }
+    if (fromDate) {
+      searchParams.set("fromDate", fromDate.toISOString());
+    }
+    if (toDate) {
+      searchParams.set("toDate", toDate.toISOString());
+    }
+    if (logLevel) {
+      searchParams.set("logLevel", logLevel);
+    }
+    if (page) {
+      searchParams.set("page", String(page));
+    }
+    if (perPage) {
+      searchParams.set("perPage", String(perPage));
+    }
+    if (_filters) {
+      if (Array.isArray(_filters)) {
+        for (const filter of _filters) {
+          searchParams.append("filters", filter);
+        }
+      } else {
+        searchParams.set("filters", _filters);
+      }
+    }
+    if (searchParams.size) {
+      return this.request(`/api/logs?${searchParams}`);
+    } else {
+      return this.request(`/api/logs`);
+    }
   }
   /**
    * Gets logs for a specific run
@@ -662,7 +3141,44 @@ var MastraClient = class extends BaseResource {
    * @returns Promise containing array of log messages
    */
   getLogForRun(params) {
-    return this.request(`/api/logs/${params.runId}?transportId=${params.transportId}`);
+    const { runId, transportId, fromDate, toDate, logLevel, filters, page, perPage } = params;
+    const _filters = filters ? Object.entries(filters).map(([key, value]) => `${key}:${value}`) : [];
+    const searchParams = new URLSearchParams();
+    if (runId) {
+      searchParams.set("runId", runId);
+    }
+    if (transportId) {
+      searchParams.set("transportId", transportId);
+    }
+    if (fromDate) {
+      searchParams.set("fromDate", fromDate.toISOString());
+    }
+    if (toDate) {
+      searchParams.set("toDate", toDate.toISOString());
+    }
+    if (logLevel) {
+      searchParams.set("logLevel", logLevel);
+    }
+    if (page) {
+      searchParams.set("page", String(page));
+    }
+    if (perPage) {
+      searchParams.set("perPage", String(perPage));
+    }
+    if (_filters) {
+      if (Array.isArray(_filters)) {
+        for (const filter of _filters) {
+          searchParams.append("filters", filter);
+        }
+      } else {
+        searchParams.set("filters", _filters);
+      }
+    }
+    if (searchParams.size) {
+      return this.request(`/api/logs/${runId}?${searchParams}`);
+    } else {
+      return this.request(`/api/logs/${runId}`);
+    }
   }
   /**
    * List of all log transports
@@ -672,56 +3188,244 @@ var MastraClient = class extends BaseResource {
     return this.request("/api/logs/transports");
   }
   /**
-   * List of all traces (paged)
-   * @param params - Parameters for filtering traces
-   * @returns Promise containing telemetry data
+   * 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.
    */
-  getTelemetry(params) {
-    const { name, scope, page, perPage, attribute } = params || {};
-    const _attribute = attribute ? Object.entries(attribute).map(([key, value]) => `${key}:${value}`) : [];
+  getMcpServers(params) {
     const searchParams = new URLSearchParams();
-    if (name) {
-      searchParams.set("name", name);
+    if (params?.limit !== void 0) {
+      searchParams.set("limit", String(params.limit));
     }
-    if (scope) {
-      searchParams.set("scope", scope);
+    if (params?.offset !== void 0) {
+      searchParams.set("offset", String(params.offset));
     }
-    if (page) {
-      searchParams.set("page", String(page));
+    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);
     }
-    if (perPage) {
-      searchParams.set("perPage", String(perPage));
+    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);
+  }
+  /**
+   * Retrieves the working memory for a specific thread (optionally resource-scoped).
+   * @param agentId - ID of the agent.
+   * @param threadId - ID of the thread.
+   * @param resourceId - Optional ID of the resource.
+   * @returns Working memory for the specified thread or resource.
+   */
+  getWorkingMemory({
+    agentId,
+    threadId,
+    resourceId,
+    runtimeContext
+  }) {
+    return this.request(
+      `/api/memory/threads/${threadId}/working-memory?agentId=${agentId}&resourceId=${resourceId}${runtimeContextQueryString(runtimeContext, "&")}`
+    );
+  }
+  searchMemory({
+    agentId,
+    resourceId,
+    threadId,
+    searchQuery,
+    memoryConfig,
+    runtimeContext
+  }) {
+    const params = new URLSearchParams({
+      searchQuery,
+      resourceId,
+      agentId
+    });
+    if (threadId) {
+      params.append("threadId", threadId);
     }
-    if (_attribute) {
-      if (Array.isArray(_attribute)) {
-        for (const attr of _attribute) {
-          searchParams.append("attribute", attr);
+    if (memoryConfig) {
+      params.append("memoryConfig", JSON.stringify(memoryConfig));
+    }
+    return this.request(`/api/memory/search?${params}${runtimeContextQueryString(runtimeContext, "&")}`);
+  }
+  /**
+   * Updates the working memory for a specific thread (optionally resource-scoped).
+   * @param agentId - ID of the agent.
+   * @param threadId - ID of the thread.
+   * @param workingMemory - The new working memory content.
+   * @param resourceId - Optional ID of the resource.
+   */
+  updateWorkingMemory({
+    agentId,
+    threadId,
+    workingMemory,
+    resourceId,
+    runtimeContext
+  }) {
+    return this.request(
+      `/api/memory/threads/${threadId}/working-memory?agentId=${agentId}${runtimeContextQueryString(runtimeContext, "&")}`,
+      {
+        method: "POST",
+        body: {
+          workingMemory,
+          resourceId
         }
-      } else {
-        searchParams.set("attribute", _attribute);
       }
+    );
+  }
+  /**
+   * Retrieves all available scorers
+   * @returns Promise containing list of available scorers
+   */
+  getScorers() {
+    return this.request("/api/scores/scorers");
+  }
+  /**
+   * Retrieves a scorer by ID
+   * @param scorerId - ID of the scorer to retrieve
+   * @returns Promise containing the scorer
+   */
+  getScorer(scorerId) {
+    return this.request(`/api/scores/scorers/${encodeURIComponent(scorerId)}`);
+  }
+  getScoresByScorerId(params) {
+    const { page, perPage, scorerId, entityId, entityType } = params;
+    const searchParams = new URLSearchParams();
+    if (entityId) {
+      searchParams.set("entityId", entityId);
     }
-    if (searchParams.size) {
-      return this.request(`/api/telemetry?${searchParams}`);
-    } else {
-      return this.request(`/api/telemetry`);
+    if (entityType) {
+      searchParams.set("entityType", entityType);
+    }
+    if (page !== void 0) {
+      searchParams.set("page", String(page));
+    }
+    if (perPage !== void 0) {
+      searchParams.set("perPage", String(perPage));
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/scores/scorer/${encodeURIComponent(scorerId)}${queryString ? `?${queryString}` : ""}`);
+  }
+  /**
+   * Retrieves scores by run ID
+   * @param params - Parameters containing run ID and pagination options
+   * @returns Promise containing scores and pagination info
+   */
+  getScoresByRunId(params) {
+    const { runId, page, perPage } = params;
+    const searchParams = new URLSearchParams();
+    if (page !== void 0) {
+      searchParams.set("page", String(page));
+    }
+    if (perPage !== void 0) {
+      searchParams.set("perPage", String(perPage));
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/scores/run/${encodeURIComponent(runId)}${queryString ? `?${queryString}` : ""}`);
+  }
+  /**
+   * Retrieves scores by entity ID and type
+   * @param params - Parameters containing entity ID, type, and pagination options
+   * @returns Promise containing scores and pagination info
+   */
+  getScoresByEntityId(params) {
+    const { entityId, entityType, page, perPage } = params;
+    const searchParams = new URLSearchParams();
+    if (page !== void 0) {
+      searchParams.set("page", String(page));
     }
+    if (perPage !== void 0) {
+      searchParams.set("perPage", String(perPage));
+    }
+    const queryString = searchParams.toString();
+    return this.request(
+      `/api/scores/entity/${encodeURIComponent(entityType)}/${encodeURIComponent(entityId)}${queryString ? `?${queryString}` : ""}`
+    );
   }
   /**
-   * Retrieves all available networks
-   * @returns Promise containing map of network IDs to network details
+   * Saves a score
+   * @param params - Parameters containing the score data to save
+   * @returns Promise containing the saved score
    */
-  getNetworks() {
-    return this.request("/api/networks");
+  saveScore(params) {
+    return this.request("/api/scores", {
+      method: "POST",
+      body: params
+    });
   }
   /**
-   * Gets a network instance by ID
-   * @param networkId - ID of the network to retrieve
-   * @returns Network instance
+   * Retrieves model providers with available keys
+   * @returns Promise containing model providers with available keys
    */
-  getNetwork(networkId) {
-    return new Network(this.options, networkId);
+  getModelProviders() {
+    return this.request(`/api/model-providers`);
+  }
+  getAITrace(traceId) {
+    return this.observability.getTrace(traceId);
+  }
+  getAITraces(params) {
+    return this.observability.getTraces(params);
+  }
+  getScoresBySpan(params) {
+    return this.observability.getScoresBySpan(params);
+  }
+  score(params) {
+    return this.observability.score(params);
+  }
+};
+
+// src/tools.ts
+var ClientTool = class {
+  id;
+  description;
+  inputSchema;
+  outputSchema;
+  execute;
+  constructor(opts) {
+    this.id = opts.id;
+    this.description = opts.description;
+    this.inputSchema = opts.inputSchema;
+    this.outputSchema = opts.outputSchema;
+    this.execute = opts.execute;
   }
 };
+function createTool(opts) {
+  return new ClientTool(opts);
+}
 
-export { MastraClient };
+export { ClientTool, MastraClient, createTool };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map