@mastra/client-js 0.0.0-cloud-transporter-20250513033346 → 0.0.0-cloudflare-deployer-dont-install-deps-20250714111754

package/dist/index.cjs

@@ -5,6 +5,9 @@ var rxjs = require('rxjs');
 var uiUtils = require('@ai-sdk/ui-utils');
 var zod = require('zod');
 var originalZodToJsonSchema = require('zod-to-json-schema');
+var tools = require('@mastra/core/tools');
+var uuid = require('@lukeed/uuid');
+var runtimeContext = require('@mastra/core/runtime-context');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -201,6 +204,33 @@ function zodToJsonSchema(zodSchema) {
   }
   return originalZodToJsonSchema__default.default(zodSchema, { $refStrategy: "none" });
 }
+function processClientTools(clientTools) {
+  if (!clientTools) {
+    return void 0;
+  }
+  return Object.fromEntries(
+    Object.entries(clientTools).map(([key, value]) => {
+      if (tools.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/resources/base.ts
 var BaseResource = class {
@@ -220,14 +250,16 @@ var BaseResource = class {
     let delay = backoffMs;
     for (let attempt = 0; attempt <= retries; attempt++) {
       try {
-        const response = await fetch(`${baseUrl}${path}`, {
+        const response = await fetch(`${baseUrl.replace(/\/$/, "")}${path}`, {
           ...options,
           headers: {
+            ...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,
           body: options.body instanceof FormData ? options.body : options.body ? JSON.stringify(options.body) : void 0
         });
         if (!response.ok) {
@@ -260,8 +292,15 @@ var BaseResource = class {
     throw lastError || new Error("Request failed");
   }
 };
-
-// src/resources/agent.ts
+function parseClientRuntimeContext(runtimeContext$1) {
+  if (runtimeContext$1) {
+    if (runtimeContext$1 instanceof runtimeContext.RuntimeContext) {
+      return Object.fromEntries(runtimeContext$1.entries());
+    }
+    return runtimeContext$1;
+  }
+  return void 0;
+}
 var AgentVoice = class extends BaseResource {
   constructor(options, agentId) {
     super(options);
@@ -308,6 +347,13 @@ var AgentVoice = class extends BaseResource {
   getSpeakers() {
     return this.request(`/api/agents/${this.agentId}/voice/speakers`);
   }
+  /**
+   * Get the listener configuration for the agent's voice provider
+   * @returns Promise containing a check if the agent has listening capabilities
+   */
+  getListener() {
+    return this.request(`/api/agents/${this.agentId}/voice/listener`);
+  }
 };
 var Agent = class extends BaseResource {
   constructor(options, agentId) {
@@ -323,35 +369,341 @@ var Agent = class extends BaseResource {
   details() {
     return this.request(`/api/agents/${this.agentId}`);
   }
-  /**
-   * Generates a response from the agent
-   * @param params - Generation parameters including prompt
-   * @returns Promise containing the generated response
-   */
-  generate(params) {
+  async generate(params) {
     const processedParams = {
       ...params,
-      output: zodToJsonSchema(params.output),
-      experimental_output: zodToJsonSchema(params.experimental_output),
-      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0
+      output: params.output ? zodToJsonSchema(params.output) : void 0,
+      experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : void 0,
+      runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      clientTools: processClientTools(params.clientTools)
     };
-    return this.request(`/api/agents/${this.agentId}/generate`, {
+    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") {
+      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 },
+            {
+              messages: response.messages,
+              toolCallId: toolCall?.toolCallId
+            }
+          );
+          const updatedMessages = [
+            {
+              role: "user",
+              content: params.messages
+            },
+            ...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 processChatResponse({
+    stream,
+    update,
+    onToolCall,
+    onFinish,
+    getCurrentDate = () => /* @__PURE__ */ new Date(),
+    lastMessage,
+    streamProtocol
+  }) {
+    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: uuid.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: uuid.v4()
+      };
+      update({
+        message: copiedMessage,
+        data: copiedData,
+        replaceLastMessage
+      });
+    }
+    if (streamProtocol === "text") {
+      await uiUtils.processTextStream({
+        stream,
+        onTextPart(value) {
+          message.content += value;
+          execUpdate();
+        }
+      });
+      onFinish?.({ message, finishReason, usage });
+    } else {
+      await uiUtils.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 } = uiUtils.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
+   * Processes the stream response and handles tool calls
    */
-  async stream(params) {
-    const processedParams = {
-      ...params,
-      output: zodToJsonSchema(params.output),
-      experimental_output: zodToJsonSchema(params.experimental_output),
-      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0
-    };
+  async processStreamResponse(processedParams, writable) {
     const response = await this.request(`/api/agents/${this.agentId}/stream`, {
       method: "POST",
       body: processedParams,
@@ -360,13 +712,135 @@ var Agent = class extends BaseResource {
     if (!response.body) {
       throw new Error("No response body");
     }
-    response.processDataStream = async (options = {}) => {
+    try {
+      const streamProtocol = processedParams.output ? "text" : "data";
+      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 }) => {
+          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
+                  },
+                  {
+                    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();
+                }
+                const originalMessages = processedParams.messages;
+                const messageArray = Array.isArray(originalMessages) ? originalMessages : [originalMessages];
+                this.processStreamResponse(
+                  {
+                    ...processedParams,
+                    messages: [...messageArray, ...messages, lastMessage]
+                  },
+                  writable
+                );
+              }
+            }
+          } else {
+            setTimeout(() => {
+              if (!writable.locked) {
+                writable.close();
+              }
+            }, 0);
+          }
+        },
+        lastMessage: void 0,
+        streamProtocol
+      });
+    } catch (error) {
+      console.error("Error processing stream response:", error);
+    }
+    return response;
+  }
+  /**
+   * Streams a response from the agent
+   * @param params - Stream parameters including prompt
+   * @returns Promise containing the enhanced Response object with processDataStream and processTextStream methods
+   */
+  async stream(params) {
+    const processedParams = {
+      ...params,
+      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.processStreamResponse(processedParams, writable);
+    const streamResponse = new Response(readable, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    streamResponse.processDataStream = async (options = {}) => {
       await uiUtils.processDataStream({
-        stream: response.body,
+        stream: streamResponse.body,
         ...options
       });
     };
-    return response;
+    streamResponse.processTextStream = async (options) => {
+      await uiUtils.processTextStream({
+        stream: streamResponse.body,
+        onTextPart: options?.onTextPart ?? (() => {
+        })
+      });
+    };
+    return streamResponse;
   }
   /**
    * Gets details about a specific tool available to the agent
@@ -578,24 +1052,24 @@ var Vector = class extends BaseResource {
   }
 };
 
-// src/resources/workflow.ts
+// src/resources/legacy-workflow.ts
 var RECORD_SEPARATOR = "";
-var Workflow = class extends BaseResource {
+var LegacyWorkflow = class extends BaseResource {
   constructor(options, workflowId) {
     super(options);
     this.workflowId = workflowId;
   }
   /**
-   * Retrieves details about the workflow
-   * @returns Promise containing workflow details including steps and graphs
+   * Retrieves details about the legacy workflow
+   * @returns Promise containing legacy workflow details including steps and graphs
    */
   details() {
-    return this.request(`/api/workflows/${this.workflowId}`);
+    return this.request(`/api/workflows/legacy/${this.workflowId}`);
   }
   /**
-   * Retrieves all runs for a workflow
+   * Retrieves all runs for a legacy workflow
    * @param params - Parameters for filtering runs
-   * @returns Promise containing workflow runs array
+   * @returns Promise containing legacy workflow runs array
    */
   runs(params) {
     const searchParams = new URLSearchParams();
@@ -615,25 +1089,13 @@ var Workflow = class extends BaseResource {
       searchParams.set("resourceId", params.resourceId);
     }
     if (searchParams.size) {
-      return this.request(`/api/workflows/${this.workflowId}/runs?${searchParams}`);
+      return this.request(`/api/workflows/legacy/${this.workflowId}/runs?${searchParams}`);
     } else {
-      return this.request(`/api/workflows/${this.workflowId}/runs`);
+      return this.request(`/api/workflows/legacy/${this.workflowId}/runs`);
     }
   }
   /**
-   * @deprecated Use `startAsync` instead
-   * Executes the workflow with the provided parameters
-   * @param params - Parameters required for workflow execution
-   * @returns Promise containing the workflow execution results
-   */
-  execute(params) {
-    return this.request(`/api/workflows/${this.workflowId}/execute`, {
-      method: "POST",
-      body: params
-    });
-  }
-  /**
-   * Creates a new workflow run
+   * Creates a new legacy workflow run
    * @returns Promise containing the generated run ID
    */
   createRun(params) {
@@ -641,34 +1103,34 @@ var Workflow = class extends BaseResource {
     if (!!params?.runId) {
       searchParams.set("runId", params.runId);
     }
-    return this.request(`/api/workflows/${this.workflowId}/createRun?${searchParams.toString()}`, {
+    return this.request(`/api/workflows/legacy/${this.workflowId}/create-run?${searchParams.toString()}`, {
       method: "POST"
     });
   }
   /**
-   * Starts a workflow run synchronously without waiting for the workflow to complete
+   * Starts a legacy workflow run synchronously without waiting for the workflow to complete
    * @param params - Object containing the runId and triggerData
    * @returns Promise containing success message
    */
   start(params) {
-    return this.request(`/api/workflows/${this.workflowId}/start?runId=${params.runId}`, {
+    return this.request(`/api/workflows/legacy/${this.workflowId}/start?runId=${params.runId}`, {
       method: "POST",
       body: params?.triggerData
     });
   }
   /**
-   * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
+   * Resumes a suspended legacy workflow step synchronously without waiting for the workflow to complete
    * @param stepId - ID of the step to resume
-   * @param runId - ID of the workflow run
-   * @param context - Context to resume the workflow with
-   * @returns Promise containing the workflow resume results
+   * @param runId - ID of the legacy workflow run
+   * @param context - Context to resume the legacy workflow with
+   * @returns Promise containing the legacy workflow resume results
    */
   resume({
     stepId,
     runId,
     context
   }) {
-    return this.request(`/api/workflows/${this.workflowId}/resume?runId=${runId}`, {
+    return this.request(`/api/workflows/legacy/${this.workflowId}/resume?runId=${runId}`, {
       method: "POST",
       body: {
         stepId,
@@ -686,18 +1148,18 @@ var Workflow = class extends BaseResource {
     if (!!params?.runId) {
       searchParams.set("runId", params.runId);
     }
-    return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
+    return this.request(`/api/workflows/legacy/${this.workflowId}/start-async?${searchParams.toString()}`, {
       method: "POST",
       body: params?.triggerData
     });
   }
   /**
-   * Resumes a suspended workflow step asynchronously and returns a promise that resolves when the workflow is complete
+   * Resumes a suspended legacy workflow step asynchronously and returns a promise that resolves when the workflow is complete
    * @param params - Object containing the runId, stepId, and context
    * @returns Promise containing the workflow resume results
    */
   resumeAsync(params) {
-    return this.request(`/api/workflows/${this.workflowId}/resume-async?runId=${params.runId}`, {
+    return this.request(`/api/workflows/legacy/${this.workflowId}/resume-async?runId=${params.runId}`, {
       method: "POST",
       body: {
         stepId: params.stepId,
@@ -751,16 +1213,16 @@ var Workflow = class extends BaseResource {
     }
   }
   /**
-   * Watches workflow transitions in real-time
+   * Watches legacy workflow transitions in real-time
    * @param runId - Optional run ID to filter the watch stream
-   * @returns AsyncGenerator that yields parsed records from the workflow watch stream
+   * @returns AsyncGenerator that yields parsed records from the legacy workflow watch stream
    */
   async watch({ runId }, onRecord) {
-    const response = await this.request(`/api/workflows/${this.workflowId}/watch?runId=${runId}`, {
+    const response = await this.request(`/api/workflows/legacy/${this.workflowId}/watch?runId=${runId}`, {
       stream: true
     });
     if (!response.ok) {
-      throw new Error(`Failed to watch workflow: ${response.statusText}`);
+      throw new Error(`Failed to watch legacy workflow: ${response.statusText}`);
     }
     if (!response.body) {
       throw new Error("Response body is null");
@@ -772,7 +1234,7 @@ var Workflow = class extends BaseResource {
 };
 
 // src/resources/tool.ts
-var Tool = class extends BaseResource {
+var Tool2 = class extends BaseResource {
   constructor(options, toolId) {
     super(options);
     this.toolId = toolId;
@@ -796,7 +1258,7 @@ var Tool = class extends BaseResource {
     }
     const body = {
       data: params.data,
-      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0
+      runtimeContext: parseClientRuntimeContext(params.runtimeContext)
     };
     return this.request(`/api/tools/${this.toolId}/execute?${url.toString()}`, {
       method: "POST",
@@ -804,14 +1266,16 @@ var Tool = class extends BaseResource {
     });
   }
 };
+
+// src/resources/workflow.ts
 var RECORD_SEPARATOR2 = "";
-var VNextWorkflow = class extends BaseResource {
+var Workflow = class extends BaseResource {
   constructor(options, workflowId) {
     super(options);
     this.workflowId = workflowId;
   }
   /**
-   * Creates an async generator that processes a readable stream and yields vNext workflow records
+   * Creates an async generator that processes a readable stream and yields workflow records
    * separated by the Record Separator character (\x1E)
    *
    * @param stream - The readable stream to process
@@ -856,16 +1320,16 @@ var VNextWorkflow = class extends BaseResource {
     }
   }
   /**
-   * Retrieves details about the vNext workflow
-   * @returns Promise containing vNext workflow details including steps and graphs
+   * Retrieves details about the workflow
+   * @returns Promise containing workflow details including steps and graphs
    */
   details() {
-    return this.request(`/api/workflows/v-next/${this.workflowId}`);
+    return this.request(`/api/workflows/${this.workflowId}`);
   }
   /**
-   * Retrieves all runs for a vNext workflow
+   * Retrieves all runs for a workflow
    * @param params - Parameters for filtering runs
-   * @returns Promise containing vNext workflow runs array
+   * @returns Promise containing workflow runs array
    */
   runs(params) {
     const searchParams = new URLSearchParams();
@@ -875,23 +1339,60 @@ var VNextWorkflow = class extends BaseResource {
     if (params?.toDate) {
       searchParams.set("toDate", params.toDate.toISOString());
     }
-    if (params?.limit) {
+    if (params?.limit !== null && params?.limit !== void 0 && !isNaN(Number(params?.limit))) {
       searchParams.set("limit", String(params.limit));
     }
-    if (params?.offset) {
+    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 (searchParams.size) {
-      return this.request(`/api/workflows/v-next/${this.workflowId}/runs?${searchParams}`);
+      return this.request(`/api/workflows/${this.workflowId}/runs?${searchParams}`);
     } else {
-      return this.request(`/api/workflows/v-next/${this.workflowId}/runs`);
+      return this.request(`/api/workflows/${this.workflowId}/runs`);
     }
   }
   /**
-   * Creates a new vNext workflow run
+   * Retrieves a specific workflow run by its ID
+   * @param runId - The ID of the workflow run to retrieve
+   * @returns Promise containing the workflow run details
+   */
+  runById(runId) {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}`);
+  }
+  /**
+   * 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
+   * @returns Promise containing the workflow run execution result
+   */
+  runExecutionResult(runId) {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}/execution-result`);
+  }
+  /**
+   * Cancels a specific workflow run by its ID
+   * @param runId - The ID of the workflow run to cancel
+   * @returns Promise containing a success message
+   */
+  cancelRun(runId) {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}/cancel`, {
+      method: "POST"
+    });
+  }
+  /**
+   * 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
+   */
+  sendRunEvent(params) {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${params.runId}/send-event`, {
+      method: "POST",
+      body: { event: params.event, data: params.data }
+    });
+  }
+  /**
+   * Creates a new workflow run
    * @param params - Optional object containing the optional runId
    * @returns Promise containing the runId of the created run
    */
@@ -900,24 +1401,24 @@ var VNextWorkflow = class extends BaseResource {
     if (!!params?.runId) {
       searchParams.set("runId", params.runId);
     }
-    return this.request(`/api/workflows/v-next/${this.workflowId}/create-run?${searchParams.toString()}`, {
+    return this.request(`/api/workflows/${this.workflowId}/create-run?${searchParams.toString()}`, {
       method: "POST"
     });
   }
   /**
-   * Starts a vNext workflow run synchronously without waiting for the workflow to complete
+   * Starts a workflow run synchronously without waiting for the workflow to complete
    * @param params - Object containing the runId, inputData and runtimeContext
    * @returns Promise containing success message
    */
   start(params) {
-    const runtimeContext = params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0;
-    return this.request(`/api/workflows/v-next/${this.workflowId}/start?runId=${params.runId}`, {
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    return this.request(`/api/workflows/${this.workflowId}/start?runId=${params.runId}`, {
       method: "POST",
       body: { inputData: params?.inputData, runtimeContext }
     });
   }
   /**
-   * Resumes a suspended vNext workflow step synchronously without waiting for the vNext workflow to complete
+   * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
    * @param params - Object containing the runId, step, resumeData and runtimeContext
    * @returns Promise containing success message
    */
@@ -927,8 +1428,8 @@ var VNextWorkflow = class extends BaseResource {
     resumeData,
     ...rest
   }) {
-    const runtimeContext = rest.runtimeContext ? Object.fromEntries(rest.runtimeContext.entries()) : void 0;
-    return this.request(`/api/workflows/v-next/${this.workflowId}/resume?runId=${runId}`, {
+    const runtimeContext = parseClientRuntimeContext(rest.runtimeContext);
+    return this.request(`/api/workflows/${this.workflowId}/resume?runId=${runId}`, {
       method: "POST",
       stream: true,
       body: {
@@ -939,29 +1440,76 @@ var VNextWorkflow = class extends BaseResource {
     });
   }
   /**
-   * Starts a vNext workflow run asynchronously and returns a promise that resolves when the vNext workflow is complete
+   * Starts a workflow run asynchronously and returns a promise that resolves when the workflow is complete
    * @param params - Object containing the optional runId, inputData and runtimeContext
-   * @returns Promise containing the vNext workflow execution results
+   * @returns Promise containing the workflow execution results
    */
   startAsync(params) {
     const searchParams = new URLSearchParams();
     if (!!params?.runId) {
       searchParams.set("runId", params.runId);
     }
-    const runtimeContext = params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0;
-    return this.request(`/api/workflows/v-next/${this.workflowId}/start-async?${searchParams.toString()}`, {
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
       method: "POST",
       body: { inputData: params.inputData, runtimeContext }
     });
   }
   /**
-   * Resumes a suspended vNext workflow step asynchronously and returns a promise that resolves when the vNext workflow is complete
+   * 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 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 },
+        stream: true
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to stream vNext workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR2);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              try {
+                const parsedChunk = JSON.parse(chunk2);
+                controller.enqueue(parsedChunk);
+              } catch {
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
+  /**
+   * Resumes a suspended workflow step asynchronously and returns a promise that resolves when the workflow is complete
    * @param params - Object containing the runId, step, resumeData and runtimeContext
-   * @returns Promise containing the vNext workflow resume results
+   * @returns Promise containing the workflow resume results
    */
   resumeAsync(params) {
-    const runtimeContext = params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0;
-    return this.request(`/api/workflows/v-next/${this.workflowId}/resume-async?runId=${params.runId}`, {
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    return this.request(`/api/workflows/${this.workflowId}/resume-async?runId=${params.runId}`, {
       method: "POST",
       body: {
         step: params.step,
@@ -971,24 +1519,51 @@ var VNextWorkflow = class extends BaseResource {
     });
   }
   /**
-   * Watches vNext workflow transitions in real-time
+   * Watches workflow transitions in real-time
    * @param runId - Optional run ID to filter the watch stream
-   * @returns AsyncGenerator that yields parsed records from the vNext workflow watch stream
+   * @returns AsyncGenerator that yields parsed records from the workflow watch stream
    */
   async watch({ runId }, onRecord) {
-    const response = await this.request(`/api/workflows/v-next/${this.workflowId}/watch?runId=${runId}`, {
+    const response = await this.request(`/api/workflows/${this.workflowId}/watch?runId=${runId}`, {
       stream: true
     });
     if (!response.ok) {
-      throw new Error(`Failed to watch vNext workflow: ${response.statusText}`);
+      throw new Error(`Failed to watch workflow: ${response.statusText}`);
     }
     if (!response.body) {
       throw new Error("Response body is null");
     }
     for await (const record of this.streamProcessor(response.body)) {
-      onRecord(record);
+      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_SEPARATOR2;
+            controller.enqueue(encoder.encode(json));
+          }
+          controller.close();
+        } catch (err) {
+          controller.error(err);
+        }
+      }
+    });
+  }
 };
 
 // src/resources/a2a.ts
@@ -1065,6 +1640,226 @@ var A2A = class extends BaseResource {
   }
 };
 
+// src/resources/mcp-tool.ts
+var MCPTool = class extends BaseResource {
+  serverId;
+  toolId;
+  constructor(options, serverId, toolId) {
+    super(options);
+    this.serverId = serverId;
+    this.toolId = toolId;
+  }
+  /**
+   * Retrieves details about this specific tool from the MCP server.
+   * @returns Promise containing the tool's information (name, description, schema).
+   */
+  details() {
+    return this.request(`/api/mcp/${this.serverId}/tools/${this.toolId}`);
+  }
+  /**
+   * Executes this specific tool on the MCP server.
+   * @param params - Parameters for tool execution, including data/args and optional runtimeContext.
+   * @returns Promise containing the result of the tool execution.
+   */
+  execute(params) {
+    const body = {};
+    if (params.data !== void 0) body.data = params.data;
+    if (params.runtimeContext !== void 0) {
+      body.runtimeContext = params.runtimeContext;
+    }
+    return this.request(`/api/mcp/${this.serverId}/tools/${this.toolId}/execute`, {
+      method: "POST",
+      body: Object.keys(body).length > 0 ? body : void 0
+    });
+  }
+};
+
+// src/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()}`);
+  }
+};
+
+// src/resources/vNextNetwork.ts
+var RECORD_SEPARATOR3 = "";
+var VNextNetwork = class extends BaseResource {
+  constructor(options, networkId) {
+    super(options);
+    this.networkId = networkId;
+  }
+  /**
+   * Retrieves details about the network
+   * @returns Promise containing vNext network details
+   */
+  details() {
+    return this.request(`/api/networks/v-next/${this.networkId}`);
+  }
+  /**
+   * Generates a response from the v-next network
+   * @param params - Generation parameters including message
+   * @returns Promise containing the generated response
+   */
+  generate(params) {
+    return this.request(`/api/networks/v-next/${this.networkId}/generate`, {
+      method: "POST",
+      body: {
+        ...params,
+        runtimeContext: parseClientRuntimeContext(params.runtimeContext)
+      }
+    });
+  }
+  /**
+   * Generates a response from the v-next network using multiple primitives
+   * @param params - Generation parameters including message
+   * @returns Promise containing the generated response
+   */
+  loop(params) {
+    return this.request(`/api/networks/v-next/${this.networkId}/loop`, {
+      method: "POST",
+      body: {
+        ...params,
+        runtimeContext: parseClientRuntimeContext(params.runtimeContext)
+      }
+    });
+  }
+  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_SEPARATOR3);
+          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 a response from the v-next network
+   * @param params - Stream parameters including message
+   * @returns Promise containing the results
+   */
+  async stream(params, onRecord) {
+    const response = await this.request(`/api/networks/v-next/${this.networkId}/stream`, {
+      method: "POST",
+      body: {
+        ...params,
+        runtimeContext: parseClientRuntimeContext(params.runtimeContext)
+      },
+      stream: true
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to stream vNext network: ${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);
+      }
+    }
+  }
+  /**
+   * Streams a response from the v-next network loop
+   * @param params - Stream parameters including message
+   * @returns Promise containing the results
+   */
+  async loopStream(params, onRecord) {
+    const response = await this.request(`/api/networks/v-next/${this.networkId}/loop-stream`, {
+      method: "POST",
+      body: {
+        ...params,
+        runtimeContext: parseClientRuntimeContext(params.runtimeContext)
+      },
+      stream: true
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to stream vNext network loop: ${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);
+      }
+    }
+  }
+};
+
 // src/client.ts
 var MastraClient = class extends BaseResource {
   constructor(options) {
@@ -1142,6 +1937,48 @@ var MastraClient = class extends BaseResource {
   getMemoryStatus(agentId) {
     return this.request(`/api/memory/status?agentId=${agentId}`);
   }
+  /**
+   * 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
    * @returns Promise containing map of tool IDs to tool details
@@ -1155,7 +1992,22 @@ var MastraClient = class extends BaseResource {
    * @returns Tool instance
    */
   getTool(toolId) {
-    return new Tool(this.options, toolId);
+    return new Tool2(this.options, toolId);
+  }
+  /**
+   * Retrieves all available legacy workflows
+   * @returns Promise containing map of legacy workflow IDs to legacy workflow details
+   */
+  getLegacyWorkflows() {
+    return this.request("/api/workflows/legacy");
+  }
+  /**
+   * Gets a legacy workflow instance by ID
+   * @param workflowId - ID of the legacy workflow to retrieve
+   * @returns Legacy Workflow instance
+   */
+  getLegacyWorkflow(workflowId) {
+    return new LegacyWorkflow(this.options, workflowId);
   }
   /**
    * Retrieves all available workflows
@@ -1172,21 +2024,6 @@ var MastraClient = class extends BaseResource {
   getWorkflow(workflowId) {
     return new Workflow(this.options, workflowId);
   }
-  /**
-   * Retrieves all available vNext workflows
-   * @returns Promise containing map of vNext workflow IDs to vNext workflow details
-   */
-  getVNextWorkflows() {
-    return this.request("/api/workflows/v-next");
-  }
-  /**
-   * Gets a vNext workflow instance by ID
-   * @param workflowId - ID of the vNext workflow to retrieve
-   * @returns vNext Workflow instance
-   */
-  getVNextWorkflow(workflowId) {
-    return new VNextWorkflow(this.options, workflowId);
-  }
   /**
    * Gets a vector instance by name
    * @param vectorName - Name of the vector to retrieve
@@ -1201,7 +2038,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
@@ -1209,7 +2080,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
@@ -1267,6 +2175,13 @@ var MastraClient = class extends BaseResource {
   getNetworks() {
     return this.request("/api/networks");
   }
+  /**
+   * Retrieves all available vNext networks
+   * @returns Promise containing map of vNext network IDs to vNext network details
+   */
+  getVNextNetworks() {
+    return this.request("/api/networks/v-next");
+  }
   /**
    * Gets a network instance by ID
    * @param networkId - ID of the network to retrieve
@@ -1275,6 +2190,62 @@ var MastraClient = class extends BaseResource {
   getNetwork(networkId) {
     return new Network(this.options, networkId);
   }
+  /**
+   * Gets a vNext network instance by ID
+   * @param networkId - ID of the vNext network to retrieve
+   * @returns vNext Network instance
+   */
+  getVNextNetwork(networkId) {
+    return new VNextNetwork(this.options, networkId);
+  }
+  /**
+   * Retrieves a list of available MCP servers.
+   * @param params - Optional parameters for pagination (limit, offset).
+   * @returns Promise containing the list of MCP servers and pagination info.
+   */
+  getMcpServers(params) {
+    const searchParams = new URLSearchParams();
+    if (params?.limit !== void 0) {
+      searchParams.set("limit", String(params.limit));
+    }
+    if (params?.offset !== void 0) {
+      searchParams.set("offset", String(params.offset));
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/mcp/v0/servers${queryString ? `?${queryString}` : ""}`);
+  }
+  /**
+   * Retrieves detailed information for a specific MCP server.
+   * @param serverId - The ID of the MCP server to retrieve.
+   * @param params - Optional parameters, e.g., specific version.
+   * @returns Promise containing the detailed MCP server information.
+   */
+  getMcpServerDetails(serverId, params) {
+    const searchParams = new URLSearchParams();
+    if (params?.version) {
+      searchParams.set("version", params.version);
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/mcp/v0/servers/${serverId}${queryString ? `?${queryString}` : ""}`);
+  }
+  /**
+   * Retrieves a list of tools for a specific MCP server.
+   * @param serverId - The ID of the MCP server.
+   * @returns Promise containing the list of tools.
+   */
+  getMcpServerTools(serverId) {
+    return this.request(`/api/mcp/${serverId}/tools`);
+  }
+  /**
+   * Gets an MCPTool resource instance for a specific tool on an MCP server.
+   * This instance can then be used to fetch details or execute the tool.
+   * @param serverId - The ID of the MCP server.
+   * @param toolId - The ID of the tool.
+   * @returns MCPTool instance.
+   */
+  getMcpServerTool(serverId, toolId) {
+    return new MCPTool(this.options, serverId, toolId);
+  }
   /**
    * Gets an A2A client for interacting with an agent via the A2A protocol
    * @param agentId - ID of the agent to interact with
@@ -1283,6 +2254,41 @@ var MastraClient = class extends BaseResource {
   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
+  }) {
+    return this.request(`/api/memory/threads/${threadId}/working-memory?agentId=${agentId}&resourceId=${resourceId}`);
+  }
+  /**
+   * 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
+  }) {
+    return this.request(`/api/memory/threads/${threadId}/working-memory?agentId=${agentId}`, {
+      method: "POST",
+      body: {
+        workingMemory,
+        resourceId
+      }
+    });
+  }
 };
 
 exports.MastraClient = MastraClient;