@mastra/client-js 0.0.0-cloud-deployer-for-core-0.19.1-20251001164939 → 0.0.0-cloud-storage-adapter-20251106204059

package/dist/index.js

@@ -1,33 +1,34 @@
 import { processDataStream, parsePartialJson } from '@ai-sdk/ui-utils';
 import { v4 } from '@lukeed/uuid';
-import { RuntimeContext } from '@mastra/core/runtime-context';
+import { getErrorFromUnknown } from '@mastra/core/error';
+import { RequestContext } from '@mastra/core/request-context';
 import { isVercelTool } from '@mastra/core/tools/is-vercel-tool';
 import { z } from 'zod';
 import originalZodToJsonSchema from 'zod-to-json-schema';
 
 // src/resources/agent.ts
-function parseClientRuntimeContext(runtimeContext) {
-  if (runtimeContext) {
-    if (runtimeContext instanceof RuntimeContext) {
-      return Object.fromEntries(runtimeContext.entries());
+function parseClientRequestContext(requestContext) {
+  if (requestContext) {
+    if (requestContext instanceof RequestContext) {
+      return Object.fromEntries(requestContext.entries());
     }
-    return runtimeContext;
+    return requestContext;
   }
   return void 0;
 }
-function base64RuntimeContext(runtimeContext) {
-  if (runtimeContext) {
-    return btoa(JSON.stringify(runtimeContext));
+function base64RequestContext(requestContext) {
+  if (requestContext) {
+    return btoa(JSON.stringify(requestContext));
   }
   return void 0;
 }
-function runtimeContextQueryString(runtimeContext) {
-  const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
-  if (!runtimeContextParam) return "";
+function requestContextQueryString(requestContext, delimiter = "?") {
+  const requestContextParam = base64RequestContext(parseClientRequestContext(requestContext));
+  if (!requestContextParam) return "";
   const searchParams = new URLSearchParams();
-  searchParams.set("runtimeContext", runtimeContextParam);
+  searchParams.set("requestContext", requestContextParam);
   const queryString = searchParams.toString();
-  return queryString ? `?${queryString}` : "";
+  return queryString ? `${delimiter}${queryString}` : "";
 }
 function isZodType(value) {
   return typeof value === "object" && value !== null && "_def" in value && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
@@ -94,11 +95,15 @@ async function sharedProcessMastraStream({
             console.info("\u{1F3C1} Stream finished");
             return;
           }
+          let json;
           try {
-            const json = JSON.parse(data);
-            await onChunk(json);
+            json = JSON.parse(data);
           } catch (error) {
             console.error("\u274C JSON parse error:", error, "Data:", data);
+            continue;
+          }
+          if (json) {
+            await onChunk(json);
           }
         }
       }
@@ -192,10 +197,9 @@ var BaseResource = class {
 async function executeToolCallAndRespond({
   response,
   params,
-  runId,
   resourceId,
   threadId,
-  runtimeContext,
+  requestContext,
   respondFn
 }) {
   if (response.finishReason === "tool-calls") {
@@ -206,22 +210,18 @@ async function executeToolCallAndRespond({
     for (const toolCall of toolCalls) {
       const clientTool = params.clientTools?.[toolCall.toolName];
       if (clientTool && clientTool.execute) {
-        const result = await clientTool.execute(
-          {
-            context: toolCall?.args,
-            runId,
-            resourceId,
-            threadId,
-            runtimeContext,
-            tracingContext: { currentSpan: void 0 },
-            suspend: async () => {
-            }
-          },
-          {
+        const result = await clientTool.execute(toolCall?.args, {
+          requestContext,
+          tracingContext: { currentSpan: void 0 },
+          agent: {
             messages: response.messages,
-            toolCallId: toolCall?.toolCallId
+            toolCallId: toolCall?.toolCallId,
+            suspend: async () => {
+            },
+            threadId,
+            resourceId
           }
-        );
+        });
         const updatedMessages = [
           ...response.response.messages || [],
           {
@@ -285,21 +285,21 @@ var AgentVoice = class extends BaseResource {
   }
   /**
    * Get available speakers for the agent's voice provider
-   * @param runtimeContext - Optional runtime context to pass as query parameter
-   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing list of available speakers
    */
-  getSpeakers(runtimeContext) {
-    return this.request(`/api/agents/${this.agentId}/voice/speakers${runtimeContextQueryString(runtimeContext)}`);
+  getSpeakers(requestContext) {
+    return this.request(`/api/agents/${this.agentId}/voice/speakers${requestContextQueryString(requestContext)}`);
   }
   /**
    * Get the listener configuration for the agent's voice provider
-   * @param runtimeContext - Optional runtime context to pass as query parameter
-   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing a check if the agent has listening capabilities
    */
-  getListener(runtimeContext) {
-    return this.request(`/api/agents/${this.agentId}/voice/listener${runtimeContextQueryString(runtimeContext)}`);
+  getListener(requestContext) {
+    return this.request(`/api/agents/${this.agentId}/voice/listener${requestContextQueryString(requestContext)}`);
   }
 };
 var Agent = class extends BaseResource {
@@ -311,27 +311,27 @@ var Agent = class extends BaseResource {
   voice;
   /**
    * Retrieves details about the agent
-   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing agent details including model and instructions
    */
-  details(runtimeContext) {
-    return this.request(`/api/agents/${this.agentId}${runtimeContextQueryString(runtimeContext)}`);
+  details(requestContext) {
+    return this.request(`/api/agents/${this.agentId}${requestContextQueryString(requestContext)}`);
   }
-  async generate(params) {
-    console.warn(
-      "Deprecation NOTICE: Generate method will switch to use generateVNext implementation the week of September 30th, 2025. Please use generateLegacy if you don't want to upgrade just yet."
-    );
-    return this.generateLegacy(params);
+  enhanceInstructions(instructions, comment) {
+    return this.request(`/api/agents/${this.agentId}/instructions/enhance`, {
+      method: "POST",
+      body: { instructions, comment }
+    });
   }
   async generateLegacy(params) {
     const processedParams = {
       ...params,
       output: params.output ? zodToJsonSchema(params.output) : void 0,
       experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : void 0,
-      runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      requestContext: parseClientRequestContext(params.requestContext),
       clientTools: processClientTools(params.clientTools)
     };
-    const { runId, resourceId, threadId, runtimeContext } = processedParams;
+    const { resourceId, threadId, requestContext } = processedParams;
     const response = await this.request(
       `/api/agents/${this.agentId}/generate-legacy`,
       {
@@ -347,22 +347,18 @@ var Agent = class extends BaseResource {
       for (const toolCall of toolCalls) {
         const clientTool = params.clientTools?.[toolCall.toolName];
         if (clientTool && clientTool.execute) {
-          const result = await clientTool.execute(
-            {
-              context: toolCall?.args,
-              runId,
-              resourceId,
-              threadId,
-              runtimeContext,
-              tracingContext: { currentSpan: void 0 },
-              suspend: async () => {
-              }
-            },
-            {
+          const result = await clientTool.execute(toolCall?.args, {
+            requestContext,
+            tracingContext: { currentSpan: void 0 },
+            agent: {
               messages: response.messages,
-              toolCallId: toolCall?.toolCallId
+              toolCallId: toolCall?.toolCallId,
+              suspend: async () => {
+              },
+              threadId,
+              resourceId
             }
-          );
+          });
           const updatedMessages = [
             ...response.response.messages,
             {
@@ -386,7 +382,7 @@ var Agent = class extends BaseResource {
     }
     return response;
   }
-  async generateVNext(messagesOrParams, options) {
+  async generate(messagesOrParams, options) {
     let params;
     if (typeof messagesOrParams === "object" && "messages" in messagesOrParams) {
       params = messagesOrParams;
@@ -398,17 +394,16 @@ var Agent = class extends BaseResource {
     }
     const processedParams = {
       ...params,
-      output: params.output ? zodToJsonSchema(params.output) : void 0,
-      runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      requestContext: parseClientRequestContext(params.requestContext),
       clientTools: processClientTools(params.clientTools),
       structuredOutput: params.structuredOutput ? {
         ...params.structuredOutput,
         schema: zodToJsonSchema(params.structuredOutput.schema)
       } : void 0
     };
-    const { runId, resourceId, threadId, runtimeContext } = processedParams;
+    const { resourceId, threadId, requestContext } = processedParams;
     const response = await this.request(
-      `/api/agents/${this.agentId}/generate/vnext`,
+      `/api/agents/${this.agentId}/generate`,
       {
         method: "POST",
         body: processedParams
@@ -418,11 +413,10 @@ var Agent = class extends BaseResource {
       return executeToolCallAndRespond({
         response,
         params,
-        runId,
         resourceId,
         threadId,
-        runtimeContext,
-        respondFn: this.generateVNext.bind(this)
+        requestContext,
+        respondFn: this.generate.bind(this)
       });
     }
     return response;
@@ -689,17 +683,6 @@ var Agent = class extends BaseResource {
     });
     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) {
-    console.warn(
-      "Deprecation NOTICE:\nStream method will switch to use streamVNext implementation the week of September 30th, 2025. Please use streamLegacy if you don't want to upgrade just yet."
-    );
-    return this.streamLegacy(params);
-  }
   /**
    * Streams a response from the agent
    * @param params - Stream parameters including prompt
@@ -710,11 +693,11 @@ var Agent = class extends BaseResource {
       ...params,
       output: params.output ? zodToJsonSchema(params.output) : void 0,
       experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : void 0,
-      runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      requestContext: parseClientRequestContext(params.requestContext),
       clientTools: processClientTools(params.clientTools)
     };
     const { readable, writable } = new TransformStream();
-    const response = await this.processStreamResponse(processedParams, writable);
+    const response = await this.processStreamResponseLegacy(processedParams, writable);
     const streamResponse = new Response(readable, {
       status: response.status,
       statusText: response.statusText,
@@ -801,6 +784,14 @@ var Agent = class extends BaseResource {
       // but this is completely wrong and this fn is probably broken. Remove ":any" and you'll see a bunch of type errors
       onChunk: async (chunk) => {
         switch (chunk.type) {
+          case "tripwire": {
+            message.parts.push({
+              type: "text",
+              text: chunk.payload.tripwireReason
+            });
+            execUpdate();
+            break;
+          }
           case "step-start": {
             if (!replaceLastMessage) {
               message.id = chunk.payload.messageId;
@@ -954,7 +945,10 @@ var Agent = class extends BaseResource {
             break;
           }
           case "error": {
-            throw new Error(chunk.payload.error);
+            throw getErrorFromUnknown(chunk.payload.error, {
+              fallbackMessage: "Unknown error in stream",
+              supportSerialization: false
+            });
           }
           case "data": {
             data.push(...chunk.payload.data);
@@ -981,8 +975,8 @@ var Agent = class extends BaseResource {
     });
     onFinish?.({ message, finishReason, usage });
   }
-  async processStreamResponse_vNext(processedParams, writable) {
-    const response = await this.request(`/api/agents/${this.agentId}/stream/vnext`, {
+  async processStreamResponse(processedParams, writable, route = "stream") {
+    const response = await this.request(`/api/agents/${this.agentId}/${route}`, {
       method: "POST",
       body: processedParams,
       stream: true
@@ -994,21 +988,20 @@ var Agent = class extends BaseResource {
       let toolCalls = [];
       let messages = [];
       const [streamForWritable, streamForProcessing] = response.body.tee();
-      const pipePromise = streamForWritable.pipeTo(
+      streamForWritable.pipeTo(
         new WritableStream({
           async write(chunk) {
+            let writer;
             try {
+              writer = writable.getWriter();
               const text = new TextDecoder().decode(chunk);
-              if (text.includes("[DONE]")) {
-                return;
-              }
+              const lines = text.split("\n\n");
+              const readableLines = lines.filter((line) => line !== "[DONE]").join("\n\n");
+              await writer.write(new TextEncoder().encode(readableLines));
             } catch {
-            }
-            const writer = writable.getWriter();
-            try {
-              await writer.write(chunk);
+              await writer?.write(chunk);
             } finally {
-              writer.releaseLock();
+              writer?.releaseLock();
             }
           }
         }),
@@ -1018,7 +1011,7 @@ var Agent = class extends BaseResource {
       ).catch((error) => {
         console.error("Error piping to writable stream:", error);
       });
-      await this.processChatResponse_vNext({
+      this.processChatResponse_vNext({
         stream: streamForProcessing,
         update: ({ message }) => {
           const existingIndex = messages.findIndex((m) => m.id === message.id);
@@ -1039,23 +1032,19 @@ var Agent = class extends BaseResource {
               const clientTool = processedParams.clientTools?.[toolCall2.toolName];
               if (clientTool && clientTool.execute) {
                 shouldExecuteClientTool = true;
-                const result = await clientTool.execute(
-                  {
-                    context: toolCall2?.args,
-                    runId: processedParams.runId,
-                    resourceId: processedParams.resourceId,
-                    threadId: processedParams.threadId,
-                    runtimeContext: processedParams.runtimeContext,
-                    // TODO: Pass proper tracing context when client-js supports tracing
-                    tracingContext: { currentSpan: void 0 },
-                    suspend: async () => {
-                    }
-                  },
-                  {
+                const result = await clientTool.execute(toolCall2?.args, {
+                  requestContext: processedParams.requestContext,
+                  // TODO: Pass proper tracing context when client-js supports tracing
+                  tracingContext: { currentSpan: void 0 },
+                  agent: {
                     messages: response.messages,
-                    toolCallId: toolCall2?.toolCallId
+                    toolCallId: toolCall2?.toolCallId,
+                    suspend: async () => {
+                    },
+                    threadId: processedParams.threadId,
+                    resourceId: processedParams.resourceId
                   }
-                );
+                });
                 const lastMessageRaw = messages[messages.length - 1];
                 const lastMessage = lastMessageRaw != null ? JSON.parse(JSON.stringify(lastMessageRaw)) : void 0;
                 const toolInvocationPart = lastMessage?.parts?.find(
@@ -1076,26 +1065,31 @@ var Agent = class extends BaseResource {
                   toolInvocation.result = result;
                 }
                 const updatedMessages = lastMessage != null ? [...messages.filter((m) => m.id !== lastMessage.id), lastMessage] : [...messages];
-                await pipePromise;
-                await this.processStreamResponse_vNext(
+                this.processStreamResponse(
                   {
                     ...processedParams,
                     messages: updatedMessages
                   },
                   writable
-                );
+                ).catch((error) => {
+                  console.error("Error processing stream response:", error);
+                });
               }
             }
             if (!shouldExecuteClientTool) {
-              await pipePromise;
-              writable.close();
+              setTimeout(() => {
+                writable.close();
+              }, 0);
             }
           } else {
-            await pipePromise;
-            writable.close();
+            setTimeout(() => {
+              writable.close();
+            }, 0);
           }
         },
         lastMessage: void 0
+      }).catch((error) => {
+        console.error("Error processing stream response:", error);
       });
     } catch (error) {
       console.error("Error processing stream response:", error);
@@ -1126,7 +1120,7 @@ var Agent = class extends BaseResource {
     };
     return streamResponse;
   }
-  async streamVNext(messagesOrParams, options) {
+  async stream(messagesOrParams, options) {
     let params;
     if (typeof messagesOrParams === "object" && "messages" in messagesOrParams) {
       params = messagesOrParams;
@@ -1138,8 +1132,7 @@ var Agent = class extends BaseResource {
     }
     const processedParams = {
       ...params,
-      output: params.output ? zodToJsonSchema(params.output) : void 0,
-      runtimeContext: parseClientRuntimeContext(params.runtimeContext),
+      requestContext: parseClientRequestContext(params.requestContext),
       clientTools: processClientTools(params.clientTools),
       structuredOutput: params.structuredOutput ? {
         ...params.structuredOutput,
@@ -1147,7 +1140,43 @@ var Agent = class extends BaseResource {
       } : void 0
     };
     const { readable, writable } = new TransformStream();
-    const response = await this.processStreamResponse_vNext(processedParams, writable);
+    const response = await this.processStreamResponse(processedParams, writable);
+    const streamResponse = new Response(readable, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    streamResponse.processDataStream = async ({
+      onChunk
+    }) => {
+      await processMastraStream({
+        stream: streamResponse.body,
+        onChunk
+      });
+    };
+    return streamResponse;
+  }
+  async approveToolCall(params) {
+    const { readable, writable } = new TransformStream();
+    const response = await this.processStreamResponse(params, writable, "approve-tool-call");
+    const streamResponse = new Response(readable, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    streamResponse.processDataStream = async ({
+      onChunk
+    }) => {
+      await processMastraStream({
+        stream: streamResponse.body,
+        onChunk
+      });
+    };
+    return streamResponse;
+  }
+  async declineToolCall(params) {
+    const { readable, writable } = new TransformStream();
+    const response = await this.processStreamResponse(params, writable, "decline-tool-call");
     const streamResponse = new Response(readable, {
       status: response.status,
       statusText: response.statusText,
@@ -1166,7 +1195,7 @@ var Agent = class extends BaseResource {
   /**
    * Processes the stream response and handles tool calls
    */
-  async processStreamResponse(processedParams, writable) {
+  async processStreamResponseLegacy(processedParams, writable) {
     const response = await this.request(`/api/agents/${this.agentId}/stream-legacy`, {
       method: "POST",
       body: processedParams,
@@ -1203,23 +1232,19 @@ var Agent = class extends BaseResource {
             for (const toolCall2 of toolCalls) {
               const clientTool = processedParams.clientTools?.[toolCall2.toolName];
               if (clientTool && clientTool.execute) {
-                const result = await clientTool.execute(
-                  {
-                    context: toolCall2?.args,
-                    runId: processedParams.runId,
-                    resourceId: processedParams.resourceId,
-                    threadId: processedParams.threadId,
-                    runtimeContext: processedParams.runtimeContext,
-                    // TODO: Pass proper tracing context when client-js supports tracing
-                    tracingContext: { currentSpan: void 0 },
-                    suspend: async () => {
-                    }
-                  },
-                  {
+                const result = await clientTool.execute(toolCall2?.args, {
+                  requestContext: processedParams.requestContext,
+                  // TODO: Pass proper tracing context when client-js supports tracing
+                  tracingContext: { currentSpan: void 0 },
+                  agent: {
                     messages: response.messages,
-                    toolCallId: toolCall2?.toolCallId
+                    toolCallId: toolCall2?.toolCallId,
+                    suspend: async () => {
+                    },
+                    threadId: processedParams.threadId,
+                    resourceId: processedParams.resourceId
                   }
-                );
+                });
                 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
@@ -1251,7 +1276,7 @@ var Agent = class extends BaseResource {
                 } finally {
                   writer.releaseLock();
                 }
-                this.processStreamResponse(
+                this.processStreamResponseLegacy(
                   {
                     ...processedParams,
                     messages: [...messages.filter((m) => m.id !== lastMessage.id), lastMessage]
@@ -1280,11 +1305,11 @@ var Agent = class extends BaseResource {
   /**
    * Gets details about a specific tool available to the agent
    * @param toolId - ID of the tool to retrieve
-   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing tool details
    */
-  getTool(toolId, runtimeContext) {
-    return this.request(`/api/agents/${this.agentId}/tools/${toolId}${runtimeContextQueryString(runtimeContext)}`);
+  getTool(toolId, requestContext) {
+    return this.request(`/api/agents/${this.agentId}/tools/${toolId}${requestContextQueryString(requestContext)}`);
   }
   /**
    * Executes a tool for the agent
@@ -1295,29 +1320,13 @@ var Agent = class extends BaseResource {
   executeTool(toolId, params) {
     const body = {
       data: params.data,
-      runtimeContext: parseClientRuntimeContext(params.runtimeContext)
+      requestContext: parseClientRequestContext(params.requestContext)
     };
     return this.request(`/api/agents/${this.agentId}/tools/${toolId}/execute`, {
       method: "POST",
       body
     });
   }
-  /**
-   * Retrieves evaluation results for the agent
-   * @param runtimeContext - Optional runtime context to pass as query parameter
-   * @returns Promise containing agent evaluations
-   */
-  evals(runtimeContext) {
-    return this.request(`/api/agents/${this.agentId}/evals/ci${runtimeContextQueryString(runtimeContext)}`);
-  }
-  /**
-   * Retrieves live evaluation results for the agent
-   * @param runtimeContext - Optional runtime context to pass as query parameter
-   * @returns Promise containing live agent evaluations
-   */
-  liveEvals(runtimeContext) {
-    return this.request(`/api/agents/${this.agentId}/evals/live${runtimeContextQueryString(runtimeContext)}`);
-  }
   /**
    * Updates the model for the agent
    * @param params - Parameters for updating the model
@@ -1329,6 +1338,15 @@ var Agent = class extends BaseResource {
       body: params
     });
   }
+  /**
+   * Resets the agent's model to the original model that was set during construction
+   * @returns Promise containing a success message
+   */
+  resetModel() {
+    return this.request(`/api/agents/${this.agentId}/model/reset`, {
+      method: "POST"
+    });
+  }
   /**
    * Updates the model for the agent in the model list
    * @param params - Parameters for updating the model
@@ -1362,72 +1380,78 @@ var MemoryThread = class extends BaseResource {
   }
   /**
    * Retrieves the memory thread details
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing thread details including title and metadata
    */
-  get() {
-    return this.request(`/api/memory/threads/${this.threadId}?agentId=${this.agentId}`);
+  get(requestContext) {
+    return this.request(
+      `/api/memory/threads/${this.threadId}?agentId=${this.agentId}${requestContextQueryString(requestContext, "&")}`
+    );
   }
   /**
    * Updates the memory thread properties
-   * @param params - Update parameters including title and metadata
+   * @param params - Update parameters including title, metadata, and optional request context
    * @returns Promise containing updated thread details
    */
   update(params) {
-    return this.request(`/api/memory/threads/${this.threadId}?agentId=${this.agentId}`, {
-      method: "PATCH",
-      body: params
-    });
+    return this.request(
+      `/api/memory/threads/${this.threadId}?agentId=${this.agentId}${requestContextQueryString(params.requestContext, "&")}`,
+      {
+        method: "PATCH",
+        body: params
+      }
+    );
   }
   /**
    * Deletes the memory thread
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing deletion result
    */
-  delete() {
-    return this.request(`/api/memory/threads/${this.threadId}?agentId=${this.agentId}`, {
-      method: "DELETE"
-    });
-  }
-  /**
-   * 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({
-      agentId: this.agentId,
-      ...params?.limit ? { limit: params.limit.toString() } : {}
-    });
-    return this.request(`/api/memory/threads/${this.threadId}/messages?${query.toString()}`);
+  delete(requestContext) {
+    return this.request(
+      `/api/memory/threads/${this.threadId}?agentId=${this.agentId}${requestContextQueryString(requestContext, "&")}`,
+      {
+        method: "DELETE"
+      }
+    );
   }
   /**
-   * Retrieves paginated messages associated with the thread with advanced filtering and selection options
-   * @param params - Pagination parameters including selectBy criteria, page, perPage, date ranges, and message inclusion options
+   * Retrieves paginated messages associated with the thread with filtering and ordering options
+   * @param params - Pagination parameters including page, perPage, orderBy, filter, include options, and request context
    * @returns Promise containing paginated thread messages with pagination metadata (total, page, perPage, hasMore)
    */
-  getMessagesPaginated({
-    selectBy,
-    ...rest
-  }) {
-    const query = new URLSearchParams({
-      ...rest,
-      ...selectBy ? { selectBy: JSON.stringify(selectBy) } : {}
-    });
-    return this.request(`/api/memory/threads/${this.threadId}/messages/paginated?${query.toString()}`);
+  listMessages(params = {}) {
+    const { page, perPage, orderBy, filter, include, resourceId, requestContext } = params;
+    const queryParams = {};
+    if (resourceId) queryParams.resourceId = resourceId;
+    if (page !== void 0) queryParams.page = String(page);
+    if (perPage !== void 0) queryParams.perPage = String(perPage);
+    if (orderBy) queryParams.orderBy = JSON.stringify(orderBy);
+    if (filter) queryParams.filter = JSON.stringify(filter);
+    if (include) queryParams.include = JSON.stringify(include);
+    const query = new URLSearchParams(queryParams);
+    const queryString = query.toString();
+    const url = `/api/memory/threads/${this.threadId}/messages${queryString ? `?${queryString}` : ""}${requestContextQueryString(requestContext, queryString ? "&" : "?")}`;
+    return this.request(url);
   }
   /**
    * Deletes one or more messages from the thread
    * @param messageIds - Can be a single message ID (string), array of message IDs,
    *                     message object with id property, or array of message objects
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing deletion result
    */
-  deleteMessages(messageIds) {
+  deleteMessages(messageIds, requestContext) {
     const query = new URLSearchParams({
       agentId: this.agentId
     });
-    return this.request(`/api/memory/messages/delete?${query.toString()}`, {
-      method: "POST",
-      body: { messageIds }
-    });
+    return this.request(
+      `/api/memory/messages/delete?${query.toString()}${requestContextQueryString(requestContext, "&")}`,
+      {
+        method: "POST",
+        body: { messageIds }
+      }
+    );
   }
 };
 
@@ -1440,12 +1464,12 @@ var Vector = class extends BaseResource {
   /**
    * Retrieves details about a specific vector index
    * @param indexName - Name of the index to get details for
-   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing vector index details
    */
-  details(indexName, runtimeContext) {
+  details(indexName, requestContext) {
     return this.request(
-      `/api/vector/${this.vectorName}/indexes/${indexName}${runtimeContextQueryString(runtimeContext)}`
+      `/api/vector/${this.vectorName}/indexes/${indexName}${requestContextQueryString(requestContext)}`
     );
   }
   /**
@@ -1460,11 +1484,11 @@ var Vector = class extends BaseResource {
   }
   /**
    * Retrieves a list of all available indexes
-   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing array of index names
    */
-  getIndexes(runtimeContext) {
-    return this.request(`/api/vector/${this.vectorName}/indexes${runtimeContextQueryString(runtimeContext)}`);
+  getIndexes(requestContext) {
+    return this.request(`/api/vector/${this.vectorName}/indexes${requestContextQueryString(requestContext)}`);
   }
   /**
    * Creates a new vector index
@@ -1509,11 +1533,11 @@ var Tool = class extends BaseResource {
   }
   /**
    * Retrieves details about the tool
-   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing tool details including description and schemas
    */
-  details(runtimeContext) {
-    return this.request(`/api/tools/${this.toolId}${runtimeContextQueryString(runtimeContext)}`);
+  details(requestContext) {
+    return this.request(`/api/tools/${this.toolId}${requestContextQueryString(requestContext)}`);
   }
   /**
    * Executes the tool with the provided parameters
@@ -1527,7 +1551,7 @@ var Tool = class extends BaseResource {
     }
     const body = {
       data: params.data,
-      runtimeContext: parseClientRuntimeContext(params.runtimeContext)
+      requestContext: parseClientRequestContext(params.requestContext)
     };
     return this.request(`/api/tools/${this.toolId}/execute?${url.toString()}`, {
       method: "POST",
@@ -1543,67 +1567,22 @@ var Workflow = class extends BaseResource {
     super(options);
     this.workflowId = workflowId;
   }
-  /**
-   * 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
-   * @returns An async generator that yields parsed records
-   */
-  async *streamProcessor(stream) {
-    const reader = stream.getReader();
-    let doneReading = false;
-    let buffer = "";
-    try {
-      while (!doneReading) {
-        const { done, value } = await reader.read();
-        doneReading = done;
-        if (done && !value) continue;
-        try {
-          const decoded = value ? new TextDecoder().decode(value) : "";
-          const chunks = (buffer + decoded).split(RECORD_SEPARATOR);
-          buffer = chunks.pop() || "";
-          for (const chunk of chunks) {
-            if (chunk) {
-              if (typeof chunk === "string") {
-                try {
-                  const parsedChunk = JSON.parse(chunk);
-                  yield parsedChunk;
-                } catch {
-                }
-              }
-            }
-          }
-        } catch {
-        }
-      }
-      if (buffer) {
-        try {
-          yield JSON.parse(buffer);
-        } catch {
-        }
-      }
-    } finally {
-      reader.cancel().catch(() => {
-      });
-    }
-  }
   /**
    * Retrieves details about the workflow
-   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing workflow details including steps and graphs
    */
-  details(runtimeContext) {
-    return this.request(`/api/workflows/${this.workflowId}${runtimeContextQueryString(runtimeContext)}`);
+  details(requestContext) {
+    return this.request(`/api/workflows/${this.workflowId}${requestContextQueryString(requestContext)}`);
   }
   /**
    * Retrieves all runs for a workflow
    * @param params - Parameters for filtering runs
-   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing workflow runs array
    */
-  runs(params, runtimeContext) {
-    const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
+  runs(params, requestContext) {
+    const requestContextParam = base64RequestContext(parseClientRequestContext(requestContext));
     const searchParams = new URLSearchParams();
     if (params?.fromDate) {
       searchParams.set("fromDate", params.fromDate.toISOString());
@@ -1611,17 +1590,21 @@ var Workflow = class extends BaseResource {
     if (params?.toDate) {
       searchParams.set("toDate", params.toDate.toISOString());
     }
-    if (params?.limit !== null && params?.limit !== void 0 && !isNaN(Number(params?.limit))) {
-      searchParams.set("limit", String(params.limit));
+    if (params?.perPage !== null && params?.perPage !== void 0) {
+      if (params.perPage === false) {
+        searchParams.set("perPage", "false");
+      } else if (typeof params.perPage === "number" && params.perPage > 0 && Number.isInteger(params.perPage)) {
+        searchParams.set("perPage", String(params.perPage));
+      }
     }
-    if (params?.offset !== null && params?.offset !== void 0 && !isNaN(Number(params?.offset))) {
-      searchParams.set("offset", String(params.offset));
+    if (params?.page !== null && params?.page !== void 0 && !isNaN(Number(params?.page))) {
+      searchParams.set("page", String(params.page));
     }
     if (params?.resourceId) {
       searchParams.set("resourceId", params.resourceId);
     }
-    if (runtimeContextParam) {
-      searchParams.set("runtimeContext", runtimeContextParam);
+    if (requestContextParam) {
+      searchParams.set("requestContext", requestContextParam);
     }
     if (searchParams.size) {
       return this.request(`/api/workflows/${this.workflowId}/runs?${searchParams}`);
@@ -1632,21 +1615,21 @@ var Workflow = class extends BaseResource {
   /**
    * Retrieves a specific workflow run by its ID
    * @param runId - The ID of the workflow run to retrieve
-   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing the workflow run details
    */
-  runById(runId, runtimeContext) {
-    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}${runtimeContextQueryString(runtimeContext)}`);
+  runById(runId, requestContext) {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}${requestContextQueryString(requestContext)}`);
   }
   /**
    * Retrieves the execution result for a specific workflow run by its ID
    * @param runId - The ID of the workflow run to retrieve the execution result for
-   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing the workflow run execution result
    */
-  runExecutionResult(runId, runtimeContext) {
+  runExecutionResult(runId, requestContext) {
     return this.request(
-      `/api/workflows/${this.workflowId}/runs/${runId}/execution-result${runtimeContextQueryString(runtimeContext)}`
+      `/api/workflows/${this.workflowId}/runs/${runId}/execution-result${requestContextQueryString(requestContext)}`
     );
   }
   /**
@@ -1659,32 +1642,12 @@ var Workflow = class extends BaseResource {
       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 }
-    });
-  }
-  /**
-   * @deprecated Use createRunAsync() instead.
-   * @throws {Error} Always throws an error directing users to use createRunAsync()
-   */
-  async createRun(_params) {
-    throw new Error(
-      "createRun() has been deprecated. Please use createRunAsync() instead.\n\nMigration guide:\n  Before: const run = workflow.createRun();\n  After:  const run = await workflow.createRunAsync();\n\nNote: createRunAsync() is an async method, so make sure your calling function is async."
-    );
-  }
   /**
    * Creates a new workflow run
    * @param params - Optional object containing the optional runId
    * @returns Promise containing the runId of the created run with methods to control execution
    */
-  async createRunAsync(params) {
+  async createRun(params) {
     const searchParams = new URLSearchParams();
     if (!!params?.runId) {
       searchParams.set("runId", params.runId);
@@ -1702,7 +1665,7 @@ var Workflow = class extends BaseResource {
         return this.start({
           runId,
           inputData: p.inputData,
-          runtimeContext: p.runtimeContext,
+          requestContext: p.requestContext,
           tracingOptions: p.tracingOptions
         });
       },
@@ -1710,22 +1673,19 @@ var Workflow = class extends BaseResource {
         return this.startAsync({
           runId,
           inputData: p.inputData,
-          runtimeContext: p.runtimeContext,
+          requestContext: p.requestContext,
           tracingOptions: p.tracingOptions
         });
       },
-      watch: async (onRecord) => {
-        return this.watch({ runId }, onRecord);
-      },
       stream: async (p) => {
-        return this.stream({ runId, inputData: p.inputData, runtimeContext: p.runtimeContext });
+        return this.stream({ runId, inputData: p.inputData, requestContext: p.requestContext });
       },
       resume: async (p) => {
         return this.resume({
           runId,
           step: p.step,
           resumeData: p.resumeData,
-          runtimeContext: p.runtimeContext,
+          requestContext: p.requestContext,
           tracingOptions: p.tracingOptions
         });
       },
@@ -1734,7 +1694,7 @@ var Workflow = class extends BaseResource {
           runId,
           step: p.step,
           resumeData: p.resumeData,
-          runtimeContext: p.runtimeContext,
+          requestContext: p.requestContext,
           tracingOptions: p.tracingOptions
         });
       },
@@ -1743,26 +1703,26 @@ var Workflow = class extends BaseResource {
           runId,
           step: p.step,
           resumeData: p.resumeData,
-          runtimeContext: p.runtimeContext
+          requestContext: p.requestContext
         });
       }
     };
   }
   /**
    * Starts a workflow run synchronously without waiting for the workflow to complete
-   * @param params - Object containing the runId, inputData and runtimeContext
+   * @param params - Object containing the runId, inputData and requestContext
    * @returns Promise containing success message
    */
   start(params) {
-    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const requestContext = parseClientRequestContext(params.requestContext);
     return this.request(`/api/workflows/${this.workflowId}/start?runId=${params.runId}`, {
       method: "POST",
-      body: { inputData: params?.inputData, runtimeContext, tracingOptions: params.tracingOptions }
+      body: { inputData: params?.inputData, requestContext, tracingOptions: params.tracingOptions }
     });
   }
   /**
    * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
-   * @param params - Object containing the runId, step, resumeData and runtimeContext
+   * @param params - Object containing the runId, step, resumeData and requestContext
    * @returns Promise containing success message
    */
   resume({
@@ -1772,20 +1732,20 @@ var Workflow = class extends BaseResource {
     tracingOptions,
     ...rest
   }) {
-    const runtimeContext = parseClientRuntimeContext(rest.runtimeContext);
+    const requestContext = parseClientRequestContext(rest.requestContext);
     return this.request(`/api/workflows/${this.workflowId}/resume?runId=${runId}`, {
       method: "POST",
       body: {
         step,
         resumeData,
-        runtimeContext,
+        requestContext,
         tracingOptions
       }
     });
   }
   /**
    * 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
+   * @param params - Object containing the optional runId, inputData and requestContext
    * @returns Promise containing the workflow execution results
    */
   startAsync(params) {
@@ -1793,15 +1753,15 @@ var Workflow = class extends BaseResource {
     if (!!params?.runId) {
       searchParams.set("runId", params.runId);
     }
-    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const requestContext = parseClientRequestContext(params.requestContext);
     return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
       method: "POST",
-      body: { inputData: params.inputData, runtimeContext, tracingOptions: params.tracingOptions }
+      body: { inputData: params.inputData, requestContext, tracingOptions: params.tracingOptions }
     });
   }
   /**
    * Starts a workflow run and returns a stream
-   * @param params - Object containing the optional runId, inputData and runtimeContext
+   * @param params - Object containing the optional runId, inputData and requestContext
    * @returns Promise containing the workflow execution results
    */
   async stream(params) {
@@ -1809,12 +1769,12 @@ var Workflow = class extends BaseResource {
     if (!!params?.runId) {
       searchParams.set("runId", params.runId);
     }
-    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const requestContext = parseClientRequestContext(params.requestContext);
     const response = await this.request(
       `/api/workflows/${this.workflowId}/stream?${searchParams.toString()}`,
       {
         method: "POST",
-        body: { inputData: params.inputData, runtimeContext, tracingOptions: params.tracingOptions },
+        body: { inputData: params.inputData, requestContext, tracingOptions: params.tracingOptions },
         stream: true
       }
     );
@@ -1899,7 +1859,7 @@ var Workflow = class extends BaseResource {
   }
   /**
    * Starts a workflow run and returns a stream
-   * @param params - Object containing the optional runId, inputData and runtimeContext
+   * @param params - Object containing the optional runId, inputData and requestContext
    * @returns Promise containing the workflow execution results
    */
   async streamVNext(params) {
@@ -1907,14 +1867,14 @@ var Workflow = class extends BaseResource {
     if (!!params?.runId) {
       searchParams.set("runId", params.runId);
     }
-    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const requestContext = parseClientRequestContext(params.requestContext);
     const response = await this.request(
       `/api/workflows/${this.workflowId}/streamVNext?${searchParams.toString()}`,
       {
         method: "POST",
         body: {
           inputData: params.inputData,
-          runtimeContext,
+          requestContext,
           closeOnSuspend: params.closeOnSuspend,
           tracingOptions: params.tracingOptions
         },
@@ -1953,62 +1913,123 @@ var Workflow = class extends BaseResource {
     });
     return response.body.pipeThrough(transformStream);
   }
+  /**
+   * Observes workflow vNext stream for a workflow run
+   * @param params - Object containing the runId
+   * @returns Promise containing the workflow execution results
+   */
+  async observeStreamVNext(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/observe-streamVNext?${searchParams.toString()}`,
+      {
+        method: "POST",
+        stream: true
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to observe stream vNext workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
   /**
    * Resumes a suspended workflow step asynchronously and returns a promise that resolves when the workflow is complete
-   * @param params - Object containing the runId, step, resumeData and runtimeContext
+   * @param params - Object containing the runId, step, resumeData and requestContext
    * @returns Promise containing the workflow resume results
    */
   resumeAsync(params) {
-    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const requestContext = parseClientRequestContext(params.requestContext);
     return this.request(`/api/workflows/${this.workflowId}/resume-async?runId=${params.runId}`, {
       method: "POST",
       body: {
         step: params.step,
         resumeData: params.resumeData,
-        runtimeContext,
+        requestContext,
         tracingOptions: params.tracingOptions
       }
     });
   }
   /**
    * Resumes a suspended workflow step that uses streamVNext asynchronously and returns a promise that resolves when the workflow is complete
-   * @param params - Object containing the runId, step, resumeData and runtimeContext
+   * @param params - Object containing the runId, step, resumeData and requestContext
    * @returns Promise containing the workflow resume results
    */
-  resumeStreamVNext(params) {
-    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
-    return this.request(`/api/workflows/${this.workflowId}/resume-stream?runId=${params.runId}`, {
-      method: "POST",
-      body: {
-        step: params.step,
-        resumeData: params.resumeData,
-        runtimeContext,
-        tracingOptions: params.tracingOptions
+  async resumeStreamVNext(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const requestContext = parseClientRequestContext(params.requestContext);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/resume-stream?${searchParams.toString()}`,
+      {
+        method: "POST",
+        body: {
+          step: params.step,
+          resumeData: params.resumeData,
+          requestContext,
+          tracingOptions: params.tracingOptions
+        },
+        stream: true
       }
-    });
-  }
-  /**
-   * Watches workflow transitions in real-time
-   * @param runId - Optional run ID to filter the watch stream
-   * @returns AsyncGenerator that yields parsed records from the workflow watch stream
-   */
-  async watch({ runId }, onRecord) {
-    const response = await this.request(`/api/workflows/${this.workflowId}/watch?runId=${runId}`, {
-      stream: true
-    });
+    );
     if (!response.ok) {
-      throw new Error(`Failed to watch workflow: ${response.statusText}`);
+      throw new Error(`Failed to stream vNext workflow: ${response.statusText}`);
     }
     if (!response.body) {
       throw new Error("Response body is null");
     }
-    for await (const record of this.streamProcessor(response.body)) {
-      if (typeof record === "string") {
-        onRecord(JSON.parse(record));
-      } else {
-        onRecord(record);
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
       }
-    }
+    });
+    return response.body.pipeThrough(transformStream);
   }
   /**
    * Creates a new ReadableStream from an iterable or async iterable of objects,
@@ -2121,22 +2142,22 @@ var MCPTool = class extends BaseResource {
   }
   /**
    * Retrieves details about this specific tool from the MCP server.
-   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing the tool's information (name, description, schema).
    */
-  details(runtimeContext) {
-    return this.request(`/api/mcp/${this.serverId}/tools/${this.toolId}${runtimeContextQueryString(runtimeContext)}`);
+  details(requestContext) {
+    return this.request(`/api/mcp/${this.serverId}/tools/${this.toolId}${requestContextQueryString(requestContext)}`);
   }
   /**
    * Executes this specific tool on the MCP server.
-   * @param params - Parameters for tool execution, including data/args and optional runtimeContext.
+   * @param params - Parameters for tool execution, including data/args and optional requestContext.
    * @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;
+    if (params.requestContext !== void 0) {
+      body.requestContext = params.requestContext;
     }
     return this.request(`/api/mcp/${this.serverId}/tools/${this.toolId}/execute`, {
       method: "POST",
@@ -2182,19 +2203,39 @@ var AgentBuilder = class extends BaseResource {
     }
   }
   /**
-   * @deprecated Use createRunAsync() instead.
-   * @throws {Error} Always throws an error directing users to use createRunAsync()
+   * Creates a transform stream that parses binary chunks into JSON records.
    */
-  async createRun(_params) {
-    throw new Error(
-      "createRun() has been deprecated. Please use createRunAsync() instead.\n\nMigration guide:\n  Before: const run = agentBuilder.createRun();\n  After:  const run = await agentBuilder.createRunAsync();\n\nNote: createRunAsync() is an async method, so make sure your calling function is async."
-    );
+  createRecordParserTransform() {
+    let failedChunk = void 0;
+    return new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR2);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
   }
   /**
    * Creates a new agent builder action run and returns the runId.
    * This calls `/api/agent-builder/:actionId/create-run`.
    */
-  async createRunAsync(params) {
+  async createRun(params) {
     const searchParams = new URLSearchParams();
     if (!!params?.runId) {
       searchParams.set("runId", params.runId);
@@ -2213,12 +2254,12 @@ var AgentBuilder = class extends BaseResource {
     if (runId) {
       searchParams.set("runId", runId);
     }
-    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
-    const { runtimeContext: _, ...actionParams } = params;
+    const requestContext = parseClientRequestContext(params.requestContext);
+    const { requestContext: _, ...actionParams } = params;
     const url = `/api/agent-builder/${this.actionId}/start-async${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
     const result = await this.request(url, {
       method: "POST",
-      body: { ...actionParams, runtimeContext }
+      body: { ...actionParams, requestContext }
     });
     return this.transformWorkflowResult(result);
   }
@@ -2229,12 +2270,12 @@ var AgentBuilder = class extends BaseResource {
   async startActionRun(params, runId) {
     const searchParams = new URLSearchParams();
     searchParams.set("runId", runId);
-    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
-    const { runtimeContext: _, ...actionParams } = params;
+    const requestContext = parseClientRequestContext(params.requestContext);
+    const { requestContext: _, ...actionParams } = params;
     const url = `/api/agent-builder/${this.actionId}/start?${searchParams.toString()}`;
     return this.request(url, {
       method: "POST",
-      body: { ...actionParams, runtimeContext }
+      body: { ...actionParams, requestContext }
     });
   }
   /**
@@ -2244,12 +2285,12 @@ var AgentBuilder = class extends BaseResource {
   async resume(params, runId) {
     const searchParams = new URLSearchParams();
     searchParams.set("runId", runId);
-    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
-    const { runtimeContext: _, ...resumeParams } = params;
+    const requestContext = parseClientRequestContext(params.requestContext);
+    const { requestContext: _, ...resumeParams } = params;
     const url = `/api/agent-builder/${this.actionId}/resume?${searchParams.toString()}`;
     return this.request(url, {
       method: "POST",
-      body: { ...resumeParams, runtimeContext }
+      body: { ...resumeParams, requestContext }
     });
   }
   /**
@@ -2259,12 +2300,12 @@ var AgentBuilder = class extends BaseResource {
   async resumeAsync(params, runId) {
     const searchParams = new URLSearchParams();
     searchParams.set("runId", runId);
-    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
-    const { runtimeContext: _, ...resumeParams } = params;
+    const requestContext = parseClientRequestContext(params.requestContext);
+    const { requestContext: _, ...resumeParams } = params;
     const url = `/api/agent-builder/${this.actionId}/resume-async?${searchParams.toString()}`;
     const result = await this.request(url, {
       method: "POST",
-      body: { ...resumeParams, runtimeContext }
+      body: { ...resumeParams, requestContext }
     });
     return this.transformWorkflowResult(result);
   }
@@ -2322,12 +2363,12 @@ var AgentBuilder = class extends BaseResource {
     if (runId) {
       searchParams.set("runId", runId);
     }
-    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
-    const { runtimeContext: _, ...actionParams } = params;
+    const requestContext = parseClientRequestContext(params.requestContext);
+    const { requestContext: _, ...actionParams } = params;
     const url = `/api/agent-builder/${this.actionId}/stream${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
     const response = await this.request(url, {
       method: "POST",
-      body: { ...actionParams, runtimeContext },
+      body: { ...actionParams, requestContext },
       stream: true
     });
     if (!response.ok) {
@@ -2336,31 +2377,7 @@ var AgentBuilder = class extends BaseResource {
     if (!response.body) {
       throw new Error("Response body is null");
     }
-    let failedChunk = void 0;
-    const transformStream = new TransformStream({
-      start() {
-      },
-      async transform(chunk, controller) {
-        try {
-          const decoded = new TextDecoder().decode(chunk);
-          const chunks = decoded.split(RECORD_SEPARATOR2);
-          for (const chunk2 of chunks) {
-            if (chunk2) {
-              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
-              try {
-                const parsedChunk = JSON.parse(newChunk);
-                controller.enqueue(parsedChunk);
-                failedChunk = void 0;
-              } catch {
-                failedChunk = newChunk;
-              }
-            }
-          }
-        } catch {
-        }
-      }
-    });
-    return response.body.pipeThrough(transformStream);
+    return response.body.pipeThrough(this.createRecordParserTransform());
   }
   /**
    * Streams agent builder action progress in real-time using VNext streaming.
@@ -2371,12 +2388,12 @@ var AgentBuilder = class extends BaseResource {
     if (runId) {
       searchParams.set("runId", runId);
     }
-    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
-    const { runtimeContext: _, ...actionParams } = params;
+    const requestContext = parseClientRequestContext(params.requestContext);
+    const { requestContext: _, ...actionParams } = params;
     const url = `/api/agent-builder/${this.actionId}/streamVNext${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
     const response = await this.request(url, {
       method: "POST",
-      body: { ...actionParams, runtimeContext },
+      body: { ...actionParams, requestContext },
       stream: true
     });
     if (!response.ok) {
@@ -2385,57 +2402,94 @@ var AgentBuilder = class extends BaseResource {
     if (!response.body) {
       throw new Error("Response body is null");
     }
-    let failedChunk = void 0;
-    const transformStream = new TransformStream({
-      start() {
-      },
-      async transform(chunk, controller) {
-        try {
-          const decoded = new TextDecoder().decode(chunk);
-          const chunks = decoded.split(RECORD_SEPARATOR2);
-          for (const chunk2 of chunks) {
-            if (chunk2) {
-              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
-              try {
-                const parsedChunk = JSON.parse(newChunk);
-                controller.enqueue(parsedChunk);
-                failedChunk = void 0;
-              } catch {
-                failedChunk = newChunk;
-              }
-            }
-          }
-        } catch {
-        }
-      }
+    return response.body.pipeThrough(this.createRecordParserTransform());
+  }
+  /**
+   * Observes an existing agent builder action run stream.
+   * Replays cached execution from the beginning, then continues with live stream.
+   * This is the recommended method for recovery after page refresh/hot reload.
+   * This calls `/api/agent-builder/:actionId/observe` (which delegates to observeStreamVNext).
+   */
+  async observeStream(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const url = `/api/agent-builder/${this.actionId}/observe?${searchParams.toString()}`;
+    const response = await this.request(url, {
+      method: "POST",
+      stream: true
     });
-    return response.body.pipeThrough(transformStream);
+    if (!response.ok) {
+      throw new Error(`Failed to observe agent builder action stream: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    return response.body.pipeThrough(this.createRecordParserTransform());
   }
   /**
-   * Watches an existing agent builder action run by runId.
-   * This is used for hot reload recovery - it loads the existing run state
-   * and streams any remaining progress.
-   * This calls `/api/agent-builder/:actionId/watch`.
+   * Observes an existing agent builder action run stream using VNext streaming API.
+   * Replays cached execution from the beginning, then continues with live stream.
+   * This calls `/api/agent-builder/:actionId/observe-streamVNext`.
    */
-  async watch({ runId, eventType }, onRecord) {
-    const url = `/api/agent-builder/${this.actionId}/watch?runId=${runId}${eventType ? `&eventType=${eventType}` : ""}`;
+  async observeStreamVNext(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const url = `/api/agent-builder/${this.actionId}/observe-streamVNext?${searchParams.toString()}`;
     const response = await this.request(url, {
-      method: "GET",
+      method: "POST",
       stream: true
     });
     if (!response.ok) {
-      throw new Error(`Failed to watch agent builder action: ${response.statusText}`);
+      throw new Error(`Failed to observe agent builder action stream VNext: ${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);
-      }
+    return response.body.pipeThrough(this.createRecordParserTransform());
+  }
+  /**
+   * Observes an existing agent builder action run stream using legacy streaming API.
+   * Replays cached execution from the beginning, then continues with live stream.
+   * This calls `/api/agent-builder/:actionId/observe-stream-legacy`.
+   */
+  async observeStreamLegacy(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const url = `/api/agent-builder/${this.actionId}/observe-stream-legacy?${searchParams.toString()}`;
+    const response = await this.request(url, {
+      method: "POST",
+      stream: true
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to observe agent builder action stream legacy: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    return response.body.pipeThrough(this.createRecordParserTransform());
+  }
+  /**
+   * Resumes a suspended agent builder action and streams the results.
+   * This calls `/api/agent-builder/:actionId/resume-stream`.
+   */
+  async resumeStream(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const requestContext = parseClientRequestContext(params.requestContext);
+    const { runId: _, requestContext: __, ...resumeParams } = params;
+    const url = `/api/agent-builder/${this.actionId}/resume-stream?${searchParams.toString()}`;
+    const response = await this.request(url, {
+      method: "POST",
+      body: { ...resumeParams, requestContext },
+      stream: true
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to resume agent builder action stream: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
     }
+    return response.body.pipeThrough(this.createRecordParserTransform());
   }
   /**
    * Gets a specific action run by its ID.
@@ -2467,11 +2521,11 @@ var AgentBuilder = class extends BaseResource {
     if (params?.toDate) {
       searchParams.set("toDate", params.toDate.toISOString());
     }
-    if (params?.limit !== void 0) {
-      searchParams.set("limit", String(params.limit));
+    if (params?.perPage !== void 0) {
+      searchParams.set("perPage", String(params.perPage));
     }
-    if (params?.offset !== void 0) {
-      searchParams.set("offset", String(params.offset));
+    if (params?.page !== void 0) {
+      searchParams.set("page", String(params.page));
     }
     if (params?.resourceId) {
       searchParams.set("resourceId", params.resourceId);
@@ -2501,17 +2555,6 @@ var AgentBuilder = class extends BaseResource {
       method: "POST"
     });
   }
-  /**
-   * Sends an event to an agent builder action run.
-   * This calls `/api/agent-builder/:actionId/runs/:runId/send-event`.
-   */
-  async sendRunEvent(params) {
-    const url = `/api/agent-builder/${this.actionId}/runs/${params.runId}/send-event`;
-    return this.request(url, {
-      method: "POST",
-      body: { event: params.event, data: params.data }
-    });
-  }
 };
 
 // src/resources/observability.ts
@@ -2520,15 +2563,15 @@ var Observability = class extends BaseResource {
     super(options);
   }
   /**
-   * Retrieves a specific AI trace by ID
+   * Retrieves a specific trace by ID
    * @param traceId - ID of the trace to retrieve
-   * @returns Promise containing the AI trace with all its spans
+   * @returns Promise containing the trace with all its spans
    */
   getTrace(traceId) {
     return this.request(`/api/observability/traces/${traceId}`);
   }
   /**
-   * Retrieves paginated list of AI traces with optional filtering
+   * Retrieves paginated list of traces with optional filtering
    * @param params - Parameters for pagination and filtering
    * @returns Promise containing paginated traces and pagination info
    */
@@ -2568,7 +2611,7 @@ var Observability = class extends BaseResource {
    * @param params - Parameters containing trace ID, span ID, and pagination options
    * @returns Promise containing scores and pagination info
    */
-  getScoresBySpan(params) {
+  listScoresBySpan(params) {
     const { traceId, spanId, page, perPage } = params;
     const searchParams = new URLSearchParams();
     if (page !== void 0) {
@@ -2590,208 +2633,6 @@ var Observability = 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()}`);
-  }
-  /**
-   * Deletes one or more messages from the thread
-   * @param messageIds - Can be a single message ID (string), array of message IDs,
-   *                     message object with id property, or array of message objects
-   * @returns Promise containing deletion result
-   */
-  deleteMessages(messageIds) {
-    const query = new URLSearchParams({
-      networkId: this.networkId
-    });
-    return this.request(`/api/memory/network/messages/delete?${query.toString()}`, {
-      method: "POST",
-      body: { messageIds }
-    });
-  }
-};
-
-// src/resources/vNextNetwork.ts
-var RECORD_SEPARATOR3 = "";
-var VNextNetwork = class extends BaseResource {
-  constructor(options, networkId) {
-    super(options);
-    this.networkId = networkId;
-  }
-  /**
-   * Retrieves details about the network
-   * @param runtimeContext - Optional runtime context to pass as query parameter
-   * @returns Promise containing vNext network details
-   */
-  details(runtimeContext) {
-    return this.request(`/api/networks/v-next/${this.networkId}${runtimeContextQueryString(runtimeContext)}`);
-  }
-  /**
-   * 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 {
   observability;
@@ -2801,18 +2642,21 @@ var MastraClient = class extends BaseResource {
   }
   /**
    * Retrieves all available agents
-   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing map of agent IDs to agent details
    */
-  getAgents(runtimeContext) {
-    const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
+  listAgents(requestContext) {
+    const requestContextParam = base64RequestContext(parseClientRequestContext(requestContext));
     const searchParams = new URLSearchParams();
-    if (runtimeContextParam) {
-      searchParams.set("runtimeContext", runtimeContextParam);
+    if (requestContextParam) {
+      searchParams.set("requestContext", requestContextParam);
     }
     const queryString = searchParams.toString();
     return this.request(`/api/agents${queryString ? `?${queryString}` : ""}`);
   }
+  listAgentsModelProviders() {
+    return this.request(`/api/agents/providers`);
+  }
   /**
    * Gets an agent instance by ID
    * @param agentId - ID of the agent to retrieve
@@ -2822,125 +2666,115 @@ var MastraClient = class extends BaseResource {
     return new Agent(this.options, agentId);
   }
   /**
-   * Retrieves memory threads for a resource
-   * @param params - Parameters containing the resource ID
-   * @returns Promise containing array of memory threads
+   * Lists memory threads for a resource with pagination support
+   * @param params - Parameters containing resource ID, pagination options, and optional request context
+   * @returns Promise containing paginated array of memory threads with metadata
    */
-  getMemoryThreads(params) {
-    return this.request(`/api/memory/threads?resourceid=${params.resourceId}&agentId=${params.agentId}`);
+  async listMemoryThreads(params) {
+    const queryParams = new URLSearchParams({
+      resourceId: params.resourceId,
+      resourceid: params.resourceId,
+      agentId: params.agentId,
+      ...params.page !== void 0 && { page: params.page.toString() },
+      ...params.perPage !== void 0 && { perPage: params.perPage.toString() },
+      ...params.orderBy && { orderBy: params.orderBy },
+      ...params.sortDirection && { sortDirection: params.sortDirection }
+    });
+    const response = await this.request(
+      `/api/memory/threads?${queryParams.toString()}${requestContextQueryString(params.requestContext, "&")}`
+    );
+    const actualResponse = "threads" in response ? response : {
+      threads: response,
+      total: response.length,
+      page: params.page ?? 0,
+      perPage: params.perPage ?? 100,
+      hasMore: false
+    };
+    return actualResponse;
   }
   /**
    * Retrieves memory config for a resource
-   * @param params - Parameters containing the resource ID
-   * @returns Promise containing array of memory threads
+   * @param params - Parameters containing the resource ID and optional request context
+   * @returns Promise containing memory configuration
    */
   getMemoryConfig(params) {
-    return this.request(`/api/memory/config?agentId=${params.agentId}`);
+    return this.request(
+      `/api/memory/config?agentId=${params.agentId}${requestContextQueryString(params.requestContext, "&")}`
+    );
   }
   /**
    * Creates a new memory thread
-   * @param params - Parameters for creating the memory thread
+   * @param params - Parameters for creating the memory thread including optional request context
    * @returns Promise containing the created memory thread
    */
   createMemoryThread(params) {
-    return this.request(`/api/memory/threads?agentId=${params.agentId}`, { method: "POST", body: params });
+    return this.request(
+      `/api/memory/threads?agentId=${params.agentId}${requestContextQueryString(params.requestContext, "&")}`,
+      { method: "POST", body: params }
+    );
   }
   /**
    * Gets a memory thread instance by ID
    * @param threadId - ID of the memory thread to retrieve
    * @returns MemoryThread instance
    */
-  getMemoryThread(threadId, agentId) {
+  getMemoryThread({ threadId, agentId }) {
     return new MemoryThread(this.options, threadId, agentId);
   }
-  getThreadMessages(threadId, opts = {}) {
+  listThreadMessages(threadId, opts = {}) {
+    if (!opts.agentId && !opts.networkId) {
+      throw new Error("Either agentId or networkId must be provided");
+    }
     let url = "";
     if (opts.agentId) {
-      url = `/api/memory/threads/${threadId}/messages?agentId=${opts.agentId}`;
+      url = `/api/memory/threads/${threadId}/messages?agentId=${opts.agentId}${requestContextQueryString(opts.requestContext, "&")}`;
     } else if (opts.networkId) {
-      url = `/api/memory/network/threads/${threadId}/messages?networkId=${opts.networkId}`;
+      url = `/api/memory/network/threads/${threadId}/messages?networkId=${opts.networkId}${requestContextQueryString(opts.requestContext, "&")}`;
     }
     return this.request(url);
   }
   deleteThread(threadId, opts = {}) {
     let url = "";
     if (opts.agentId) {
-      url = `/api/memory/threads/${threadId}?agentId=${opts.agentId}`;
+      url = `/api/memory/threads/${threadId}?agentId=${opts.agentId}${requestContextQueryString(opts.requestContext, "&")}`;
     } else if (opts.networkId) {
-      url = `/api/memory/network/threads/${threadId}?networkId=${opts.networkId}`;
+      url = `/api/memory/network/threads/${threadId}?networkId=${opts.networkId}${requestContextQueryString(opts.requestContext, "&")}`;
     }
     return this.request(url, { method: "DELETE" });
   }
   /**
    * Saves messages to memory
-   * @param params - Parameters containing messages to save
+   * @param params - Parameters containing messages to save and optional request context
    * @returns Promise containing the saved messages
    */
   saveMessageToMemory(params) {
-    return this.request(`/api/memory/save-messages?agentId=${params.agentId}`, {
-      method: "POST",
-      body: params
-    });
-  }
-  /**
-   * Gets the status of the memory system
-   * @returns Promise containing memory system status
-   */
-  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
-    });
+    return this.request(
+      `/api/memory/save-messages?agentId=${params.agentId}${requestContextQueryString(params.requestContext, "&")}`,
+      {
+        method: "POST",
+        body: params
+      }
+    );
   }
   /**
    * Gets the status of the memory system
+   * @param agentId - The agent ID
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing memory system status
    */
-  getNetworkMemoryStatus(networkId) {
-    return this.request(`/api/memory/network/status?networkId=${networkId}`);
+  getMemoryStatus(agentId, requestContext) {
+    return this.request(`/api/memory/status?agentId=${agentId}${requestContextQueryString(requestContext, "&")}`);
   }
   /**
    * Retrieves all available tools
-   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing map of tool IDs to tool details
    */
-  getTools(runtimeContext) {
-    const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
+  listTools(requestContext) {
+    const requestContextParam = base64RequestContext(parseClientRequestContext(requestContext));
     const searchParams = new URLSearchParams();
-    if (runtimeContextParam) {
-      searchParams.set("runtimeContext", runtimeContextParam);
+    if (requestContextParam) {
+      searchParams.set("requestContext", requestContextParam);
     }
     const queryString = searchParams.toString();
     return this.request(`/api/tools${queryString ? `?${queryString}` : ""}`);
@@ -2955,14 +2789,14 @@ var MastraClient = class extends BaseResource {
   }
   /**
    * Retrieves all available workflows
-   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing map of workflow IDs to workflow details
    */
-  getWorkflows(runtimeContext) {
-    const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
+  listWorkflows(requestContext) {
+    const requestContextParam = base64RequestContext(parseClientRequestContext(requestContext));
     const searchParams = new URLSearchParams();
-    if (runtimeContextParam) {
-      searchParams.set("runtimeContext", runtimeContextParam);
+    if (requestContextParam) {
+      searchParams.set("requestContext", requestContextParam);
     }
     const queryString = searchParams.toString();
     return this.request(`/api/workflows${queryString ? `?${queryString}` : ""}`);
@@ -3002,7 +2836,7 @@ var MastraClient = class extends BaseResource {
    * @param params - Parameters for filtering logs
    * @returns Promise containing array of log messages
    */
-  getLogs(params) {
+  listLogs(params) {
     const { transportId, fromDate, toDate, logLevel, filters, page, perPage } = params;
     const _filters = filters ? Object.entries(filters).map(([key, value]) => `${key}:${value}`) : [];
     const searchParams = new URLSearchParams();
@@ -3088,78 +2922,21 @@ var MastraClient = class extends BaseResource {
    * List of all log transports
    * @returns Promise containing list of log transports
    */
-  getLogTransports() {
+  listLogTransports() {
     return this.request("/api/logs/transports");
   }
-  /**
-   * List of all traces (paged)
-   * @param params - Parameters for filtering traces
-   * @returns Promise containing telemetry data
-   */
-  getTelemetry(params) {
-    const { name, scope, page, perPage, attribute, fromDate, toDate } = params || {};
-    const _attribute = attribute ? Object.entries(attribute).map(([key, value]) => `${key}:${value}`) : [];
-    const searchParams = new URLSearchParams();
-    if (name) {
-      searchParams.set("name", name);
-    }
-    if (scope) {
-      searchParams.set("scope", scope);
-    }
-    if (page) {
-      searchParams.set("page", String(page));
-    }
-    if (perPage) {
-      searchParams.set("perPage", String(perPage));
-    }
-    if (_attribute) {
-      if (Array.isArray(_attribute)) {
-        for (const attr of _attribute) {
-          searchParams.append("attribute", attr);
-        }
-      } else {
-        searchParams.set("attribute", _attribute);
-      }
-    }
-    if (fromDate) {
-      searchParams.set("fromDate", fromDate.toISOString());
-    }
-    if (toDate) {
-      searchParams.set("toDate", toDate.toISOString());
-    }
-    if (searchParams.size) {
-      return this.request(`/api/telemetry?${searchParams}`);
-    } else {
-      return this.request(`/api/telemetry`);
-    }
-  }
-  /**
-   * 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 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).
+   * @param params - Optional parameters for pagination (perPage, page).
    * @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?.perPage !== void 0) {
+      searchParams.set("perPage", String(params.perPage));
     }
-    if (params?.offset !== void 0) {
-      searchParams.set("offset", String(params.offset));
+    if (params?.page !== void 0) {
+      searchParams.set("page", String(params.page));
     }
     const queryString = searchParams.toString();
     return this.request(`/api/mcp/v0/servers${queryString ? `?${queryString}` : ""}`);
@@ -3214,9 +2991,33 @@ var MastraClient = class extends BaseResource {
   getWorkingMemory({
     agentId,
     threadId,
-    resourceId
+    resourceId,
+    requestContext
   }) {
-    return this.request(`/api/memory/threads/${threadId}/working-memory?agentId=${agentId}&resourceId=${resourceId}`);
+    return this.request(
+      `/api/memory/threads/${threadId}/working-memory?agentId=${agentId}&resourceId=${resourceId}${requestContextQueryString(requestContext, "&")}`
+    );
+  }
+  searchMemory({
+    agentId,
+    resourceId,
+    threadId,
+    searchQuery,
+    memoryConfig,
+    requestContext
+  }) {
+    const params = new URLSearchParams({
+      searchQuery,
+      resourceId,
+      agentId
+    });
+    if (threadId) {
+      params.append("threadId", threadId);
+    }
+    if (memoryConfig) {
+      params.append("memoryConfig", JSON.stringify(memoryConfig));
+    }
+    return this.request(`/api/memory/search?${params}${requestContextQueryString(requestContext, "&")}`);
   }
   /**
    * Updates the working memory for a specific thread (optionally resource-scoped).
@@ -3229,21 +3030,25 @@ var MastraClient = class extends BaseResource {
     agentId,
     threadId,
     workingMemory,
-    resourceId
+    resourceId,
+    requestContext
   }) {
-    return this.request(`/api/memory/threads/${threadId}/working-memory?agentId=${agentId}`, {
-      method: "POST",
-      body: {
-        workingMemory,
-        resourceId
+    return this.request(
+      `/api/memory/threads/${threadId}/working-memory?agentId=${agentId}${requestContextQueryString(requestContext, "&")}`,
+      {
+        method: "POST",
+        body: {
+          workingMemory,
+          resourceId
+        }
       }
-    });
+    );
   }
   /**
    * Retrieves all available scorers
    * @returns Promise containing list of available scorers
    */
-  getScorers() {
+  listScorers() {
     return this.request("/api/scores/scorers");
   }
   /**
@@ -3254,7 +3059,7 @@ var MastraClient = class extends BaseResource {
   getScorer(scorerId) {
     return this.request(`/api/scores/scorers/${encodeURIComponent(scorerId)}`);
   }
-  getScoresByScorerId(params) {
+  listScoresByScorerId(params) {
     const { page, perPage, scorerId, entityId, entityType } = params;
     const searchParams = new URLSearchParams();
     if (entityId) {
@@ -3277,7 +3082,7 @@ var MastraClient = class extends BaseResource {
    * @param params - Parameters containing run ID and pagination options
    * @returns Promise containing scores and pagination info
    */
-  getScoresByRunId(params) {
+  listScoresByRunId(params) {
     const { runId, page, perPage } = params;
     const searchParams = new URLSearchParams();
     if (page !== void 0) {
@@ -3294,7 +3099,7 @@ var MastraClient = class extends BaseResource {
    * @param params - Parameters containing entity ID, type, and pagination options
    * @returns Promise containing scores and pagination info
    */
-  getScoresByEntityId(params) {
+  listScoresByEntityId(params) {
     const { entityId, entityType, page, perPage } = params;
     const searchParams = new URLSearchParams();
     if (page !== void 0) {
@@ -3319,21 +3124,14 @@ var MastraClient = class extends BaseResource {
       body: params
     });
   }
-  /**
-   * Retrieves model providers with available keys
-   * @returns Promise containing model providers with available keys
-   */
-  getModelProviders() {
-    return this.request(`/api/model-providers`);
-  }
-  getAITrace(traceId) {
+  getTrace(traceId) {
     return this.observability.getTrace(traceId);
   }
-  getAITraces(params) {
+  getTraces(params) {
     return this.observability.getTraces(params);
   }
-  getScoresBySpan(params) {
-    return this.observability.getScoresBySpan(params);
+  listScoresBySpan(params) {
+    return this.observability.listScoresBySpan(params);
   }
   score(params) {
     return this.observability.score(params);