@mastra/client-js 0.0.0-fix-fetching-workflow-snapshots-20250625000954 → 0.0.0-fix-traces-pagination-plus-share-for-cloud-20250717083008

package/dist/index.js

@@ -1,9 +1,10 @@
 import { AbstractAgent, EventType } from '@ag-ui/client';
 import { Observable } from 'rxjs';
-import { processDataStream, parsePartialJson } from '@ai-sdk/ui-utils';
+import { processTextStream, processDataStream, parsePartialJson } from '@ai-sdk/ui-utils';
 import { ZodSchema } from 'zod';
 import originalZodToJsonSchema from 'zod-to-json-schema';
 import { isVercelTool } from '@mastra/core/tools';
+import { v4 } from '@lukeed/uuid';
 import { RuntimeContext } from '@mastra/core/runtime-context';
 
 // src/adapters/agui.ts
@@ -252,6 +253,7 @@ var BaseResource = class {
             // 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) {
@@ -375,7 +377,11 @@ var Agent = class extends BaseResource {
       body: processedParams
     });
     if (response.finishReason === "tool-calls") {
-      for (const toolCall of response.toolCalls) {
+      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(
@@ -418,7 +424,8 @@ var Agent = class extends BaseResource {
     onToolCall,
     onFinish,
     getCurrentDate = () => /* @__PURE__ */ new Date(),
-    lastMessage
+    lastMessage,
+    streamProtocol
   }) {
     const replaceLastMessage = lastMessage?.role === "assistant";
     let step = replaceLastMessage ? 1 + // find max step in existing tool invocations:
@@ -426,7 +433,7 @@ var Agent = class extends BaseResource {
       return Math.max(max, toolInvocation.step ?? 0);
     }, 0) ?? 0) : 0;
     const message = replaceLastMessage ? structuredClone(lastMessage) : {
-      id: crypto.randomUUID(),
+      id: v4(),
       createdAt: getCurrentDate(),
       role: "assistant",
       content: "",
@@ -471,7 +478,7 @@ var Agent = class extends BaseResource {
         // 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: crypto.randomUUID()
+        revisionId: v4()
       };
       update({
         message: copiedMessage,
@@ -479,228 +486,213 @@ var Agent = class extends BaseResource {
         replaceLastMessage
       });
     }
-    await processDataStream({
-      stream,
-      onTextPart(value) {
-        if (currentTextPart == null) {
-          currentTextPart = {
-            type: "text",
-            text: value
-          };
-          message.parts.push(currentTextPart);
-        } else {
-          currentTextPart.text += value;
+    if (streamProtocol === "text") {
+      await processTextStream({
+        stream,
+        onTextPart(value) {
+          message.content += value;
+          execUpdate();
         }
-        message.content += value;
-        execUpdate();
-      },
-      onReasoningPart(value) {
-        if (currentReasoningTextDetail == null) {
-          currentReasoningTextDetail = { type: "text", text: value };
-          if (currentReasoningPart != null) {
-            currentReasoningPart.details.push(currentReasoningTextDetail);
+      });
+      onFinish?.({ message, finishReason, usage });
+    } else {
+      await processDataStream({
+        stream,
+        onTextPart(value) {
+          if (currentTextPart == null) {
+            currentTextPart = {
+              type: "text",
+              text: value
+            };
+            message.parts.push(currentTextPart);
+          } else {
+            currentTextPart.text += value;
           }
-        } 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 {
+          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();
-        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();
+          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);
         }
-      },
-      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) {
-    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 processDataStream({
-        stream: streamResponse.body,
-        ...options
       });
-    };
-    return streamResponse;
+      onFinish?.({ message, finishReason, usage });
+    }
   }
   /**
    * Processes the stream response and handles tool calls
@@ -715,80 +707,135 @@ var Agent = class extends BaseResource {
       throw new Error("No response body");
     }
     try {
+      const streamProtocol = processedParams.output ? "text" : "data";
       let toolCalls = [];
-      let finishReasonToolCalls = false;
       let messages = [];
-      let hasProcessedToolCalls = false;
-      response.clone().body.pipeTo(writable);
-      await this.processChatResponse({
-        stream: response.clone().body,
+      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: ({ finishReason, message }) => {
+        onFinish: async ({ finishReason, message }) => {
           if (finishReason === "tool-calls") {
-            finishReasonToolCalls = true;
             const toolCall = [...message?.parts ?? []].reverse().find((part) => part.type === "tool-invocation")?.toolInvocation;
             if (toolCall) {
               toolCalls.push(toolCall);
             }
-          }
-        },
-        lastMessage: void 0
-      });
-      if (finishReasonToolCalls && !hasProcessedToolCalls) {
-        hasProcessedToolCalls = true;
-        for (const toolCall of toolCalls) {
-          const clientTool = processedParams.clientTools?.[toolCall.toolName];
-          if (clientTool && clientTool.execute) {
-            const result = await clientTool.execute(
-              {
-                context: toolCall?.args,
-                runId: processedParams.runId,
-                resourceId: processedParams.resourceId,
-                threadId: processedParams.threadId,
-                runtimeContext: processedParams.runtimeContext
-              },
-              {
-                messages: response.messages,
-                toolCallId: toolCall?.toolCallId
+            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
+                );
               }
-            );
-            const lastMessage = JSON.parse(JSON.stringify(messages[messages.length - 1]));
-            const toolInvocationPart = lastMessage?.parts?.find(
-              (part) => part.type === "tool-invocation" && part.toolInvocation?.toolCallId === toolCall.toolCallId
-            );
-            if (toolInvocationPart) {
-              toolInvocationPart.toolInvocation = {
-                ...toolInvocationPart.toolInvocation,
-                state: "result",
-                result
-              };
             }
-            const toolInvocation = lastMessage?.toolInvocations?.find(
-              (toolInvocation2) => toolInvocation2.toolCallId === toolCall.toolCallId
-            );
-            if (toolInvocation) {
-              toolInvocation.state = "result";
-              toolInvocation.result = result;
-            }
-            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 processDataStream({
+        stream: streamResponse.body,
+        ...options
+      });
+    };
+    streamResponse.processTextStream = async (options) => {
+      await processTextStream({
+        stream: streamResponse.body,
+        onTextPart: options?.onTextPart ?? (() => {
+        })
+      });
+    };
+    return streamResponse;
+  }
   /**
    * Gets details about a specific tool available to the agent
    * @param toolId - ID of the tool to retrieve
@@ -1286,10 +1333,10 @@ var Workflow = class extends BaseResource {
     if (params?.toDate) {
       searchParams.set("toDate", params.toDate.toISOString());
     }
-    if (params?.limit !== void 0) {
+    if (params?.limit !== null && params?.limit !== void 0 && !isNaN(Number(params?.limit))) {
       searchParams.set("limit", String(params.limit));
     }
-    if (params?.offset !== void 0) {
+    if (params?.offset !== null && params?.offset !== void 0 && !isNaN(Number(params?.offset))) {
       searchParams.set("offset", String(params.offset));
     }
     if (params?.resourceId) {
@@ -1317,6 +1364,27 @@ var Workflow = class extends BaseResource {
   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
@@ -1406,6 +1474,7 @@ var Workflow = class extends BaseResource {
     if (!response.body) {
       throw new Error("Response body is null");
     }
+    let failedChunk = void 0;
     const transformStream = new TransformStream({
       start() {
       },
@@ -1415,10 +1484,13 @@ var Workflow = class extends BaseResource {
           const chunks = decoded.split(RECORD_SEPARATOR2);
           for (const chunk2 of chunks) {
             if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
               try {
-                const parsedChunk = JSON.parse(chunk2);
+                const parsedChunk = JSON.parse(newChunk);
                 controller.enqueue(parsedChunk);
-              } catch {
+                failedChunk = void 0;
+              } catch (error) {
+                failedChunk = newChunk;
               }
             }
           }
@@ -1600,6 +1672,54 @@ var MCPTool = class extends BaseResource {
   }
 };
 
+// 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 {
@@ -1622,7 +1742,10 @@ var VNextNetwork = class extends BaseResource {
   generate(params) {
     return this.request(`/api/networks/v-next/${this.networkId}/generate`, {
       method: "POST",
-      body: params
+      body: {
+        ...params,
+        runtimeContext: parseClientRuntimeContext(params.runtimeContext)
+      }
     });
   }
   /**
@@ -1633,7 +1756,10 @@ var VNextNetwork = class extends BaseResource {
   loop(params) {
     return this.request(`/api/networks/v-next/${this.networkId}/loop`, {
       method: "POST",
-      body: params
+      body: {
+        ...params,
+        runtimeContext: parseClientRuntimeContext(params.runtimeContext)
+      }
     });
   }
   async *streamProcessor(stream) {
@@ -1682,7 +1808,10 @@ var VNextNetwork = class extends BaseResource {
   async stream(params, onRecord) {
     const response = await this.request(`/api/networks/v-next/${this.networkId}/stream`, {
       method: "POST",
-      body: params,
+      body: {
+        ...params,
+        runtimeContext: parseClientRuntimeContext(params.runtimeContext)
+      },
       stream: true
     });
     if (!response.ok) {
@@ -1699,53 +1828,33 @@ var VNextNetwork = class extends BaseResource {
       }
     }
   }
-};
-
-// 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
+   * Streams a response from the v-next network loop
+   * @param params - Stream parameters including message
+   * @returns Promise containing the results
    */
-  getMessages(params) {
-    const query = new URLSearchParams({
-      networkId: this.networkId,
-      ...params?.limit ? { limit: params.limit.toString() } : {}
+  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
     });
-    return this.request(`/api/memory/network/threads/${this.threadId}/messages?${query.toString()}`);
+    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);
+      }
+    }
   }
 };
 
@@ -2143,6 +2252,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
+      }
+    });
+  }
 };
 
 export { MastraClient };