@mastra/client-js 0.0.0-ai-telementry-ui-20250908102126 → 0.0.0-break-rename-vnext-legacy-20250926163953

package/dist/index.js

@@ -15,6 +15,20 @@ function parseClientRuntimeContext(runtimeContext) {
   }
   return void 0;
 }
+function base64RuntimeContext(runtimeContext) {
+  if (runtimeContext) {
+    return btoa(JSON.stringify(runtimeContext));
+  }
+  return void 0;
+}
+function runtimeContextQueryString(runtimeContext) {
+  const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
+  if (!runtimeContextParam) return "";
+  const searchParams = new URLSearchParams();
+  searchParams.set("runtimeContext", runtimeContextParam);
+  const queryString = searchParams.toString();
+  return queryString ? `?${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";
 }
@@ -26,7 +40,7 @@ function zodToJsonSchema(zodSchema) {
     const fn = "toJSONSchema";
     return z[fn].call(z, zodSchema);
   }
-  return originalZodToJsonSchema(zodSchema, { $refStrategy: "none" });
+  return originalZodToJsonSchema(zodSchema, { $refStrategy: "relative" });
 }
 
 // src/utils/process-client-tools.ts
@@ -59,7 +73,7 @@ function processClientTools(clientTools) {
 }
 
 // src/utils/process-mastra-stream.ts
-async function processMastraStream({
+async function sharedProcessMastraStream({
   stream,
   onChunk
 }) {
@@ -77,7 +91,7 @@ async function processMastraStream({
         if (line.startsWith("data: ")) {
           const data = line.slice(6);
           if (data === "[DONE]") {
-            console.log("\u{1F3C1} Stream finished");
+            console.info("\u{1F3C1} Stream finished");
             return;
           }
           try {
@@ -93,6 +107,24 @@ async function processMastraStream({
     reader.releaseLock();
   }
 }
+async function processMastraNetworkStream({
+  stream,
+  onChunk
+}) {
+  return sharedProcessMastraStream({
+    stream,
+    onChunk
+  });
+}
+async function processMastraStream({
+  stream,
+  onChunk
+}) {
+  return sharedProcessMastraStream({
+    stream,
+    onChunk
+  });
+}
 
 // src/resources/base.ts
 var BaseResource = class {
@@ -181,7 +213,9 @@ async function executeToolCallAndRespond({
             resourceId,
             threadId,
             runtimeContext,
-            tracingContext: { currentSpan: void 0 }
+            tracingContext: { currentSpan: void 0 },
+            suspend: async () => {
+            }
           },
           {
             messages: response.messages,
@@ -189,11 +223,7 @@ async function executeToolCallAndRespond({
           }
         );
         const updatedMessages = [
-          {
-            role: "user",
-            content: params.messages
-          },
-          ...response.response.messages,
+          ...response.response.messages || [],
           {
             role: "tool",
             content: [
@@ -255,17 +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
    * @returns Promise containing list of available speakers
    */
-  getSpeakers() {
-    return this.request(`/api/agents/${this.agentId}/voice/speakers`);
+  getSpeakers(runtimeContext) {
+    return this.request(`/api/agents/${this.agentId}/voice/speakers${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
    * Get the listener configuration for the agent's voice provider
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing a check if the agent has listening capabilities
    */
-  getListener() {
-    return this.request(`/api/agents/${this.agentId}/voice/listener`);
+  getListener(runtimeContext) {
+    return this.request(`/api/agents/${this.agentId}/voice/listener${runtimeContextQueryString(runtimeContext)}`);
   }
 };
 var Agent = class extends BaseResource {
@@ -277,16 +311,11 @@ var Agent = class extends BaseResource {
   voice;
   /**
    * Retrieves details about the agent
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing agent details including model and instructions
    */
-  details() {
-    return this.request(`/api/agents/${this.agentId}`);
-  }
-  async generate(params) {
-    console.warn(
-      "Deprecation NOTICE:Generate method will switch to use generateVNext implementation September 16th. Please use generateLegacy if you don't want to upgrade just yet."
-    );
-    return this.generateLegacy(params);
+  details(runtimeContext) {
+    return this.request(`/api/agents/${this.agentId}${runtimeContextQueryString(runtimeContext)}`);
   }
   async generateLegacy(params) {
     const processedParams = {
@@ -319,7 +348,9 @@ var Agent = class extends BaseResource {
               resourceId,
               threadId,
               runtimeContext,
-              tracingContext: { currentSpan: void 0 }
+              tracingContext: { currentSpan: void 0 },
+              suspend: async () => {
+              }
             },
             {
               messages: response.messages,
@@ -327,10 +358,6 @@ var Agent = class extends BaseResource {
             }
           );
           const updatedMessages = [
-            {
-              role: "user",
-              content: params.messages
-            },
             ...response.response.messages,
             {
               role: "tool",
@@ -353,16 +380,29 @@ var Agent = class extends BaseResource {
     }
     return response;
   }
-  async generateVNext(params) {
+  async generate(messagesOrParams, options) {
+    let params;
+    if (typeof messagesOrParams === "object" && "messages" in messagesOrParams) {
+      params = messagesOrParams;
+    } else {
+      params = {
+        messages: messagesOrParams,
+        ...options
+      };
+    }
     const processedParams = {
       ...params,
       output: params.output ? zodToJsonSchema(params.output) : void 0,
       runtimeContext: parseClientRuntimeContext(params.runtimeContext),
-      clientTools: processClientTools(params.clientTools)
+      clientTools: processClientTools(params.clientTools),
+      structuredOutput: params.structuredOutput ? {
+        ...params.structuredOutput,
+        schema: zodToJsonSchema(params.structuredOutput.schema)
+      } : void 0
     };
     const { runId, resourceId, threadId, runtimeContext } = processedParams;
     const response = await this.request(
-      `/api/agents/${this.agentId}/generate/vnext`,
+      `/api/agents/${this.agentId}/generate`,
       {
         method: "POST",
         body: processedParams
@@ -376,7 +416,7 @@ var Agent = class extends BaseResource {
         resourceId,
         threadId,
         runtimeContext,
-        respondFn: this.generateVNext.bind(this)
+        respondFn: this.generate.bind(this)
       });
     }
     return response;
@@ -648,12 +688,6 @@ var Agent = class extends BaseResource {
    * @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 September 16th. 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
@@ -863,7 +897,7 @@ var Agent = class extends BaseResource {
               step,
               toolCallId: chunk.payload.toolCallId,
               toolName: chunk.payload.toolName,
-              args: void 0
+              args: chunk.payload.args
             };
             message.toolInvocations.push(invocation);
             updateToolInvocationPart(chunk.payload.toolCallId, invocation);
@@ -917,14 +951,14 @@ var Agent = class extends BaseResource {
           }
           case "step-finish": {
             step += 1;
-            currentTextPart = chunk.payload.isContinued ? currentTextPart : void 0;
+            currentTextPart = chunk.payload.stepResult.isContinued ? currentTextPart : void 0;
             currentReasoningPart = void 0;
             currentReasoningTextDetail = void 0;
             execUpdate();
             break;
           }
           case "finish": {
-            finishReason = chunk.payload.finishReason;
+            finishReason = chunk.payload.stepResult.reason;
             if (chunk.payload.usage != null) {
               usage = chunk.payload.usage;
             }
@@ -936,7 +970,7 @@ 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`, {
+    const response = await this.request(`/api/agents/${this.agentId}/stream`, {
       method: "POST",
       body: processedParams,
       stream: true
@@ -948,9 +982,28 @@ var Agent = class extends BaseResource {
       let toolCalls = [];
       let messages = [];
       const [streamForWritable, streamForProcessing] = response.body.tee();
-      streamForWritable.pipeTo(writable, {
-        preventClose: true
-      }).catch((error) => {
+      streamForWritable.pipeTo(
+        new WritableStream({
+          async write(chunk) {
+            try {
+              const text = new TextDecoder().decode(chunk);
+              if (text.includes("[DONE]")) {
+                return;
+              }
+            } catch {
+            }
+            const writer = writable.getWriter();
+            try {
+              await writer.write(chunk);
+            } finally {
+              writer.releaseLock();
+            }
+          }
+        }),
+        {
+          preventClose: true
+        }
+      ).catch((error) => {
         console.error("Error piping to writable stream:", error);
       });
       this.processChatResponse_vNext({
@@ -980,14 +1033,17 @@ var Agent = class extends BaseResource {
                     threadId: processedParams.threadId,
                     runtimeContext: processedParams.runtimeContext,
                     // TODO: Pass proper tracing context when client-js supports tracing
-                    tracingContext: { currentSpan: void 0 }
+                    tracingContext: { currentSpan: void 0 },
+                    suspend: async () => {
+                    }
                   },
                   {
                     messages: response.messages,
                     toolCallId: toolCall2?.toolCallId
                   }
                 );
-                const lastMessage = JSON.parse(JSON.stringify(messages[messages.length - 1]));
+                const lastMessageRaw = messages[messages.length - 1];
+                const lastMessage = lastMessageRaw != null ? JSON.parse(JSON.stringify(lastMessageRaw)) : void 0;
                 const toolInvocationPart = lastMessage?.parts?.find(
                   (part) => part.type === "tool-invocation" && part.toolInvocation?.toolCallId === toolCall2.toolCallId
                 );
@@ -1005,25 +1061,11 @@ var Agent = class extends BaseResource {
                   toolInvocation.state = "result";
                   toolInvocation.result = result;
                 }
-                const writer = writable.getWriter();
-                try {
-                  await writer.write(
-                    new TextEncoder().encode(
-                      "a:" + JSON.stringify({
-                        toolCallId: toolCall2.toolCallId,
-                        result
-                      }) + "\n"
-                    )
-                  );
-                } finally {
-                  writer.releaseLock();
-                }
-                const originalMessages = processedParams.messages;
-                const messageArray = Array.isArray(originalMessages) ? originalMessages : [originalMessages];
+                const updatedMessages = lastMessage != null ? [...messages.filter((m) => m.id !== lastMessage.id), lastMessage] : [...messages];
                 this.processStreamResponse_vNext(
                   {
                     ...processedParams,
-                    messages: [...messageArray, ...messages.filter((m) => m.id !== lastMessage.id), lastMessage]
+                    messages: updatedMessages
                   },
                   writable
                 ).catch((error) => {
@@ -1046,12 +1088,49 @@ var Agent = class extends BaseResource {
     }
     return response;
   }
-  async streamVNext(params) {
+  async network(params) {
+    const response = await this.request(`/api/agents/${this.agentId}/network`, {
+      method: "POST",
+      body: params,
+      stream: true
+    });
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    const streamResponse = new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    streamResponse.processDataStream = async ({
+      onChunk
+    }) => {
+      await processMastraNetworkStream({
+        stream: streamResponse.body,
+        onChunk
+      });
+    };
+    return streamResponse;
+  }
+  async stream(messagesOrParams, options) {
+    let params;
+    if (typeof messagesOrParams === "object" && "messages" in messagesOrParams) {
+      params = messagesOrParams;
+    } else {
+      params = {
+        messages: messagesOrParams,
+        ...options
+      };
+    }
     const processedParams = {
       ...params,
       output: params.output ? zodToJsonSchema(params.output) : void 0,
       runtimeContext: parseClientRuntimeContext(params.runtimeContext),
-      clientTools: processClientTools(params.clientTools)
+      clientTools: processClientTools(params.clientTools),
+      structuredOutput: params.structuredOutput ? {
+        ...params.structuredOutput,
+        schema: zodToJsonSchema(params.structuredOutput.schema)
+      } : void 0
     };
     const { readable, writable } = new TransformStream();
     const response = await this.processStreamResponse_vNext(processedParams, writable);
@@ -1118,7 +1197,9 @@ var Agent = class extends BaseResource {
                     threadId: processedParams.threadId,
                     runtimeContext: processedParams.runtimeContext,
                     // TODO: Pass proper tracing context when client-js supports tracing
-                    tracingContext: { currentSpan: void 0 }
+                    tracingContext: { currentSpan: void 0 },
+                    suspend: async () => {
+                    }
                   },
                   {
                     messages: response.messages,
@@ -1156,12 +1237,10 @@ var Agent = class extends BaseResource {
                 } finally {
                   writer.releaseLock();
                 }
-                const originalMessages = processedParams.messages;
-                const messageArray = Array.isArray(originalMessages) ? originalMessages : [originalMessages];
                 this.processStreamResponse(
                   {
                     ...processedParams,
-                    messages: [...messageArray, ...messages.filter((m) => m.id !== lastMessage.id), lastMessage]
+                    messages: [...messages.filter((m) => m.id !== lastMessage.id), lastMessage]
                   },
                   writable
                 ).catch((error) => {
@@ -1187,10 +1266,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
    * @returns Promise containing tool details
    */
-  getTool(toolId) {
-    return this.request(`/api/agents/${this.agentId}/tools/${toolId}`);
+  getTool(toolId, runtimeContext) {
+    return this.request(`/api/agents/${this.agentId}/tools/${toolId}${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
    * Executes a tool for the agent
@@ -1201,7 +1281,7 @@ var Agent = class extends BaseResource {
   executeTool(toolId, params) {
     const body = {
       data: params.data,
-      runtimeContext: params.runtimeContext ? Object.fromEntries(params.runtimeContext.entries()) : void 0
+      runtimeContext: parseClientRuntimeContext(params.runtimeContext)
     };
     return this.request(`/api/agents/${this.agentId}/tools/${toolId}/execute`, {
       method: "POST",
@@ -1210,17 +1290,19 @@ var Agent = class extends BaseResource {
   }
   /**
    * Retrieves evaluation results for the agent
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing agent evaluations
    */
-  evals() {
-    return this.request(`/api/agents/${this.agentId}/evals/ci`);
+  evals(runtimeContext) {
+    return this.request(`/api/agents/${this.agentId}/evals/ci${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
    * Retrieves live evaluation results for the agent
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing live agent evaluations
    */
-  liveEvals() {
-    return this.request(`/api/agents/${this.agentId}/evals/live`);
+  liveEvals(runtimeContext) {
+    return this.request(`/api/agents/${this.agentId}/evals/live${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
    * Updates the model for the agent
@@ -1233,61 +1315,27 @@ var Agent = class extends BaseResource {
       body: params
     });
   }
-};
-var Network = class extends BaseResource {
-  constructor(options, networkId) {
-    super(options);
-    this.networkId = networkId;
-  }
-  /**
-   * Retrieves details about the network
-   * @returns Promise containing network details
-   */
-  details() {
-    return this.request(`/api/networks/${this.networkId}`);
-  }
   /**
-   * Generates a response from the agent
-   * @param params - Generation parameters including prompt
-   * @returns Promise containing the generated response
+   * Updates the model for the agent in the model list
+   * @param params - Parameters for updating the model
+   * @returns Promise containing the updated model
    */
-  generate(params) {
-    const processedParams = {
-      ...params,
-      output: zodToJsonSchema(params.output),
-      experimental_output: zodToJsonSchema(params.experimental_output)
-    };
-    return this.request(`/api/networks/${this.networkId}/generate`, {
+  updateModelInModelList({ modelConfigId, ...params }) {
+    return this.request(`/api/agents/${this.agentId}/models/${modelConfigId}`, {
       method: "POST",
-      body: processedParams
+      body: params
     });
   }
   /**
-   * Streams a response from the agent
-   * @param params - Stream parameters including prompt
-   * @returns Promise containing the enhanced Response object with processDataStream method
+   * Reorders the models for the agent
+   * @param params - Parameters for reordering the model list
+   * @returns Promise containing the updated model list
    */
-  async stream(params) {
-    const processedParams = {
-      ...params,
-      output: zodToJsonSchema(params.output),
-      experimental_output: zodToJsonSchema(params.experimental_output)
-    };
-    const response = await this.request(`/api/networks/${this.networkId}/stream`, {
+  reorderModelList(params) {
+    return this.request(`/api/agents/${this.agentId}/models/reorder`, {
       method: "POST",
-      body: processedParams,
-      stream: true
+      body: params
     });
-    if (!response.body) {
-      throw new Error("No response body");
-    }
-    response.processDataStream = async (options = {}) => {
-      await processDataStream({
-        stream: response.body,
-        ...options
-      });
-    };
-    return response;
   }
 };
 
@@ -1378,10 +1426,13 @@ var Vector = class extends BaseResource {
   /**
    * Retrieves details about a specific vector index
    * @param indexName - Name of the index to get details for
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing vector index details
    */
-  details(indexName) {
-    return this.request(`/api/vector/${this.vectorName}/indexes/${indexName}`);
+  details(indexName, runtimeContext) {
+    return this.request(
+      `/api/vector/${this.vectorName}/indexes/${indexName}${runtimeContextQueryString(runtimeContext)}`
+    );
   }
   /**
    * Deletes a vector index
@@ -1395,10 +1446,11 @@ var Vector = class extends BaseResource {
   }
   /**
    * Retrieves a list of all available indexes
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing array of index names
    */
-  getIndexes() {
-    return this.request(`/api/vector/${this.vectorName}/indexes`);
+  getIndexes(runtimeContext) {
+    return this.request(`/api/vector/${this.vectorName}/indexes${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
    * Creates a new vector index
@@ -1435,187 +1487,6 @@ var Vector = class extends BaseResource {
   }
 };
 
-// src/resources/legacy-workflow.ts
-var RECORD_SEPARATOR = "";
-var LegacyWorkflow = class extends BaseResource {
-  constructor(options, workflowId) {
-    super(options);
-    this.workflowId = workflowId;
-  }
-  /**
-   * Retrieves details about the legacy workflow
-   * @returns Promise containing legacy workflow details including steps and graphs
-   */
-  details() {
-    return this.request(`/api/workflows/legacy/${this.workflowId}`);
-  }
-  /**
-   * Retrieves all runs for a legacy workflow
-   * @param params - Parameters for filtering runs
-   * @returns Promise containing legacy workflow runs array
-   */
-  runs(params) {
-    const searchParams = new URLSearchParams();
-    if (params?.fromDate) {
-      searchParams.set("fromDate", params.fromDate.toISOString());
-    }
-    if (params?.toDate) {
-      searchParams.set("toDate", params.toDate.toISOString());
-    }
-    if (params?.limit) {
-      searchParams.set("limit", String(params.limit));
-    }
-    if (params?.offset) {
-      searchParams.set("offset", String(params.offset));
-    }
-    if (params?.resourceId) {
-      searchParams.set("resourceId", params.resourceId);
-    }
-    if (searchParams.size) {
-      return this.request(`/api/workflows/legacy/${this.workflowId}/runs?${searchParams}`);
-    } else {
-      return this.request(`/api/workflows/legacy/${this.workflowId}/runs`);
-    }
-  }
-  /**
-   * Creates a new legacy workflow run
-   * @returns Promise containing the generated run ID
-   */
-  createRun(params) {
-    const searchParams = new URLSearchParams();
-    if (!!params?.runId) {
-      searchParams.set("runId", params.runId);
-    }
-    return this.request(`/api/workflows/legacy/${this.workflowId}/create-run?${searchParams.toString()}`, {
-      method: "POST"
-    });
-  }
-  /**
-   * Starts a legacy workflow run synchronously without waiting for the workflow to complete
-   * @param params - Object containing the runId and triggerData
-   * @returns Promise containing success message
-   */
-  start(params) {
-    return this.request(`/api/workflows/legacy/${this.workflowId}/start?runId=${params.runId}`, {
-      method: "POST",
-      body: params?.triggerData
-    });
-  }
-  /**
-   * Resumes a suspended legacy workflow step synchronously without waiting for the workflow to complete
-   * @param stepId - ID of the step to resume
-   * @param runId - ID of the legacy workflow run
-   * @param context - Context to resume the legacy workflow with
-   * @returns Promise containing the legacy workflow resume results
-   */
-  resume({
-    stepId,
-    runId,
-    context
-  }) {
-    return this.request(`/api/workflows/legacy/${this.workflowId}/resume?runId=${runId}`, {
-      method: "POST",
-      body: {
-        stepId,
-        context
-      }
-    });
-  }
-  /**
-   * Starts a workflow run asynchronously and returns a promise that resolves when the workflow is complete
-   * @param params - Object containing the optional runId and triggerData
-   * @returns Promise containing the workflow execution results
-   */
-  startAsync(params) {
-    const searchParams = new URLSearchParams();
-    if (!!params?.runId) {
-      searchParams.set("runId", params.runId);
-    }
-    return this.request(`/api/workflows/legacy/${this.workflowId}/start-async?${searchParams.toString()}`, {
-      method: "POST",
-      body: params?.triggerData
-    });
-  }
-  /**
-   * Resumes a suspended legacy workflow step asynchronously and returns a promise that resolves when the workflow is complete
-   * @param params - Object containing the runId, stepId, and context
-   * @returns Promise containing the workflow resume results
-   */
-  resumeAsync(params) {
-    return this.request(`/api/workflows/legacy/${this.workflowId}/resume-async?runId=${params.runId}`, {
-      method: "POST",
-      body: {
-        stepId: params.stepId,
-        context: params.context
-      }
-    });
-  }
-  /**
-   * Creates an async generator that processes a readable stream and yields 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(() => {
-      });
-    }
-  }
-  /**
-   * Watches legacy workflow transitions in real-time
-   * @param runId - Optional run ID to filter the watch stream
-   * @returns AsyncGenerator that yields parsed records from the legacy workflow watch stream
-   */
-  async watch({ runId }, onRecord) {
-    const response = await this.request(`/api/workflows/legacy/${this.workflowId}/watch?runId=${runId}`, {
-      stream: true
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to watch legacy workflow: ${response.statusText}`);
-    }
-    if (!response.body) {
-      throw new Error("Response body is null");
-    }
-    for await (const record of this.streamProcessor(response.body)) {
-      onRecord(record);
-    }
-  }
-};
-
 // src/resources/tool.ts
 var Tool = class extends BaseResource {
   constructor(options, toolId) {
@@ -1624,10 +1495,11 @@ var Tool = class extends BaseResource {
   }
   /**
    * Retrieves details about the tool
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing tool details including description and schemas
    */
-  details() {
-    return this.request(`/api/tools/${this.toolId}`);
+  details(runtimeContext) {
+    return this.request(`/api/tools/${this.toolId}${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
    * Executes the tool with the provided parameters
@@ -1651,7 +1523,7 @@ var Tool = class extends BaseResource {
 };
 
 // src/resources/workflow.ts
-var RECORD_SEPARATOR2 = "";
+var RECORD_SEPARATOR = "";
 var Workflow = class extends BaseResource {
   constructor(options, workflowId) {
     super(options);
@@ -1675,7 +1547,7 @@ var Workflow = class extends BaseResource {
         if (done && !value) continue;
         try {
           const decoded = value ? new TextDecoder().decode(value) : "";
-          const chunks = (buffer + decoded).split(RECORD_SEPARATOR2);
+          const chunks = (buffer + decoded).split(RECORD_SEPARATOR);
           buffer = chunks.pop() || "";
           for (const chunk of chunks) {
             if (chunk) {
@@ -1704,17 +1576,20 @@ var Workflow = class extends BaseResource {
   }
   /**
    * Retrieves details about the workflow
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing workflow details including steps and graphs
    */
-  details() {
-    return this.request(`/api/workflows/${this.workflowId}`);
+  details(runtimeContext) {
+    return this.request(`/api/workflows/${this.workflowId}${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
    * Retrieves all runs for a workflow
    * @param params - Parameters for filtering runs
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing workflow runs array
    */
-  runs(params) {
+  runs(params, runtimeContext) {
+    const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
     const searchParams = new URLSearchParams();
     if (params?.fromDate) {
       searchParams.set("fromDate", params.fromDate.toISOString());
@@ -1731,6 +1606,9 @@ var Workflow = class extends BaseResource {
     if (params?.resourceId) {
       searchParams.set("resourceId", params.resourceId);
     }
+    if (runtimeContextParam) {
+      searchParams.set("runtimeContext", runtimeContextParam);
+    }
     if (searchParams.size) {
       return this.request(`/api/workflows/${this.workflowId}/runs?${searchParams}`);
     } else {
@@ -1740,18 +1618,22 @@ 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
    * @returns Promise containing the workflow run details
    */
-  runById(runId) {
-    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}`);
+  runById(runId, runtimeContext) {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
    * Retrieves the execution result for a specific workflow run by its ID
    * @param runId - The ID of the workflow run to retrieve the execution result for
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing the workflow run execution result
    */
-  runExecutionResult(runId) {
-    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}/execution-result`);
+  runExecutionResult(runId, runtimeContext) {
+    return this.request(
+      `/api/workflows/${this.workflowId}/runs/${runId}/execution-result${runtimeContextQueryString(runtimeContext)}`
+    );
   }
   /**
    * Cancels a specific workflow run by its ID
@@ -1774,27 +1656,61 @@ var Workflow = class extends BaseResource {
       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
+   * @returns Promise containing the runId of the created run with methods to control execution
    */
-  createRun(params) {
+  async createRunAsync(params) {
     const searchParams = new URLSearchParams();
     if (!!params?.runId) {
       searchParams.set("runId", params.runId);
     }
-    return this.request(`/api/workflows/${this.workflowId}/create-run?${searchParams.toString()}`, {
-      method: "POST"
-    });
-  }
-  /**
-   * Creates a new workflow run (alias for createRun)
-   * @param params - Optional object containing the optional runId
-   * @returns Promise containing the runId of the created run
-   */
-  createRunAsync(params) {
-    return this.createRun(params);
+    const res = await this.request(
+      `/api/workflows/${this.workflowId}/create-run?${searchParams.toString()}`,
+      {
+        method: "POST"
+      }
+    );
+    const runId = res.runId;
+    return {
+      runId,
+      start: async (p) => {
+        return this.start({ runId, inputData: p.inputData, runtimeContext: p.runtimeContext });
+      },
+      startAsync: async (p) => {
+        return this.startAsync({ runId, inputData: p.inputData, runtimeContext: p.runtimeContext });
+      },
+      watch: async (onRecord) => {
+        return this.watch({ runId }, onRecord);
+      },
+      stream: async (p) => {
+        return this.stream({ runId, inputData: p.inputData, runtimeContext: p.runtimeContext });
+      },
+      resume: async (p) => {
+        return this.resume({ runId, step: p.step, resumeData: p.resumeData, runtimeContext: p.runtimeContext });
+      },
+      resumeAsync: async (p) => {
+        return this.resumeAsync({ runId, step: p.step, resumeData: p.resumeData, runtimeContext: p.runtimeContext });
+      },
+      resumeStreamVNext: async (p) => {
+        return this.resumeStreamVNext({
+          runId,
+          step: p.step,
+          resumeData: p.resumeData,
+          runtimeContext: p.runtimeContext
+        });
+      }
+    };
   }
   /**
    * Starts a workflow run synchronously without waiting for the workflow to complete
@@ -1822,7 +1738,6 @@ var Workflow = class extends BaseResource {
     const runtimeContext = parseClientRuntimeContext(rest.runtimeContext);
     return this.request(`/api/workflows/${this.workflowId}/resume?runId=${runId}`, {
       method: "POST",
-      stream: true,
       body: {
         step,
         resumeData,
@@ -1865,6 +1780,104 @@ var Workflow = class extends BaseResource {
         stream: true
       }
     );
+    if (!response.ok) {
+      throw new Error(`Failed to stream workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
+  /**
+   * Observes workflow stream for a workflow run
+   * @param params - Object containing the runId
+   * @returns Promise containing the workflow execution results
+   */
+  async observeStream(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/observe-stream?${searchParams.toString()}`,
+      {
+        method: "POST",
+        stream: true
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to observe workflow stream: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
+  /**
+   * Starts a workflow run and returns a stream
+   * @param params - Object containing the optional runId, inputData and runtimeContext
+   * @returns Promise containing the workflow execution results
+   */
+  async streamVNext(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/streamVNext?${searchParams.toString()}`,
+      {
+        method: "POST",
+        body: { inputData: params.inputData, runtimeContext, closeOnSuspend: params.closeOnSuspend },
+        stream: true
+      }
+    );
     if (!response.ok) {
       throw new Error(`Failed to stream vNext workflow: ${response.statusText}`);
     }
@@ -1878,7 +1891,7 @@ var Workflow = class extends BaseResource {
       async transform(chunk, controller) {
         try {
           const decoded = new TextDecoder().decode(chunk);
-          const chunks = decoded.split(RECORD_SEPARATOR2);
+          const chunks = decoded.split(RECORD_SEPARATOR);
           for (const chunk2 of chunks) {
             if (chunk2) {
               const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
@@ -1913,6 +1926,22 @@ var Workflow = class extends BaseResource {
       }
     });
   }
+  /**
+   * Resumes a suspended workflow step that uses streamVNext asynchronously and returns a promise that resolves when the workflow is complete
+   * @param params - Object containing the runId, step, resumeData and runtimeContext
+   * @returns Promise containing the workflow resume results
+   */
+  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
+      }
+    });
+  }
   /**
    * Watches workflow transitions in real-time
    * @param runId - Optional run ID to filter the watch stream
@@ -1949,7 +1978,7 @@ var Workflow = class extends BaseResource {
       async start(controller) {
         try {
           for await (const record of records) {
-            const json = JSON.stringify(record) + RECORD_SEPARATOR2;
+            const json = JSON.stringify(record) + RECORD_SEPARATOR;
             controller.enqueue(encoder.encode(json));
           }
           controller.close();
@@ -2047,10 +2076,11 @@ 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
    * @returns Promise containing the tool's information (name, description, schema).
    */
-  details() {
-    return this.request(`/api/mcp/${this.serverId}/tools/${this.toolId}`);
+  details(runtimeContext) {
+    return this.request(`/api/mcp/${this.serverId}/tools/${this.toolId}${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
    * Executes this specific tool on the MCP server.
@@ -2071,7 +2101,7 @@ var MCPTool = class extends BaseResource {
 };
 
 // src/resources/agent-builder.ts
-var RECORD_SEPARATOR3 = "";
+var RECORD_SEPARATOR2 = "";
 var AgentBuilder = class extends BaseResource {
   constructor(options, actionId) {
     super(options);
@@ -2106,11 +2136,20 @@ var AgentBuilder = class extends BaseResource {
       };
     }
   }
+  /**
+   * @deprecated Use createRunAsync() instead.
+   * @throws {Error} Always throws an error directing users to use createRunAsync()
+   */
+  async createRun(_params) {
+    throw new Error(
+      "createRun() has been deprecated. Please use createRunAsync() instead.\n\nMigration guide:\n  Before: const run = agentBuilder.createRun();\n  After:  const run = await agentBuilder.createRunAsync();\n\nNote: createRunAsync() is an async method, so make sure your calling function is async."
+    );
+  }
   /**
    * Creates a new agent builder action run and returns the runId.
    * This calls `/api/agent-builder/:actionId/create-run`.
    */
-  async createRun(params) {
+  async createRunAsync(params) {
     const searchParams = new URLSearchParams();
     if (!!params?.runId) {
       searchParams.set("runId", params.runId);
@@ -2120,14 +2159,6 @@ var AgentBuilder = class extends BaseResource {
       method: "POST"
     });
   }
-  /**
-   * Creates a new workflow run (alias for createRun)
-   * @param params - Optional object containing the optional runId
-   * @returns Promise containing the runId of the created run
-   */
-  createRunAsync(params) {
-    return this.createRun(params);
-  }
   /**
    * Starts agent builder action asynchronously and waits for completion.
    * This calls `/api/agent-builder/:actionId/start-async`.
@@ -2210,7 +2241,7 @@ var AgentBuilder = class extends BaseResource {
         if (done && !value) continue;
         try {
           const decoded = value ? new TextDecoder().decode(value) : "";
-          const chunks = (buffer + decoded).split(RECORD_SEPARATOR3);
+          const chunks = (buffer + decoded).split(RECORD_SEPARATOR2);
           buffer = chunks.pop() || "";
           for (const chunk of chunks) {
             if (chunk) {
@@ -2267,7 +2298,7 @@ var AgentBuilder = class extends BaseResource {
       async transform(chunk, controller) {
         try {
           const decoded = new TextDecoder().decode(chunk);
-          const chunks = decoded.split(RECORD_SEPARATOR3);
+          const chunks = decoded.split(RECORD_SEPARATOR2);
           for (const chunk2 of chunks) {
             if (chunk2) {
               const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
@@ -2316,7 +2347,7 @@ var AgentBuilder = class extends BaseResource {
       async transform(chunk, controller) {
         try {
           const decoded = new TextDecoder().decode(chunk);
-          const chunks = decoded.split(RECORD_SEPARATOR3);
+          const chunks = decoded.split(RECORD_SEPARATOR2);
           for (const chunk2 of chunks) {
             if (chunk2) {
               const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
@@ -2487,6 +2518,12 @@ var Observability = class extends BaseResource {
     const queryString = searchParams.toString();
     return this.request(`/api/observability/traces${queryString ? `?${queryString}` : ""}`);
   }
+  score(params) {
+    return this.request(`/api/observability/traces/score`, {
+      method: "POST",
+      body: { ...params }
+    });
+  }
 };
 
 // src/resources/network-memory-thread.ts
@@ -2553,7 +2590,7 @@ var NetworkMemoryThread = class extends BaseResource {
 };
 
 // src/resources/vNextNetwork.ts
-var RECORD_SEPARATOR4 = "";
+var RECORD_SEPARATOR3 = "";
 var VNextNetwork = class extends BaseResource {
   constructor(options, networkId) {
     super(options);
@@ -2561,10 +2598,11 @@ var VNextNetwork = class extends BaseResource {
   }
   /**
    * Retrieves details about the network
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing vNext network details
    */
-  details() {
-    return this.request(`/api/networks/v-next/${this.networkId}`);
+  details(runtimeContext) {
+    return this.request(`/api/networks/v-next/${this.networkId}${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
    * Generates a response from the v-next network
@@ -2605,7 +2643,7 @@ var VNextNetwork = class extends BaseResource {
         if (done && !value) continue;
         try {
           const decoded = value ? new TextDecoder().decode(value) : "";
-          const chunks = (buffer + decoded).split(RECORD_SEPARATOR4);
+          const chunks = (buffer + decoded).split(RECORD_SEPARATOR3);
           buffer = chunks.pop() || "";
           for (const chunk of chunks) {
             if (chunk) {
@@ -2699,10 +2737,17 @@ var MastraClient = class extends BaseResource {
   }
   /**
    * Retrieves all available agents
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing map of agent IDs to agent details
    */
-  getAgents() {
-    return this.request("/api/agents");
+  getAgents(runtimeContext) {
+    const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
+    const searchParams = new URLSearchParams();
+    if (runtimeContextParam) {
+      searchParams.set("runtimeContext", runtimeContextParam);
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/agents${queryString ? `?${queryString}` : ""}`);
   }
   /**
    * Gets an agent instance by ID
@@ -2720,6 +2765,14 @@ var MastraClient = class extends BaseResource {
   getMemoryThreads(params) {
     return this.request(`/api/memory/threads?resourceid=${params.resourceId}&agentId=${params.agentId}`);
   }
+  /**
+   * Retrieves memory config for a resource
+   * @param params - Parameters containing the resource ID
+   * @returns Promise containing array of memory threads
+   */
+  getMemoryConfig(params) {
+    return this.request(`/api/memory/config?agentId=${params.agentId}`);
+  }
   /**
    * Creates a new memory thread
    * @param params - Parameters for creating the memory thread
@@ -2736,6 +2789,24 @@ var MastraClient = class extends BaseResource {
   getMemoryThread(threadId, agentId) {
     return new MemoryThread(this.options, threadId, agentId);
   }
+  getThreadMessages(threadId, opts = {}) {
+    let url = "";
+    if (opts.agentId) {
+      url = `/api/memory/threads/${threadId}/messages?agentId=${opts.agentId}`;
+    } else if (opts.networkId) {
+      url = `/api/memory/network/threads/${threadId}/messages?networkId=${opts.networkId}`;
+    }
+    return this.request(url);
+  }
+  deleteThread(threadId, opts = {}) {
+    let url = "";
+    if (opts.agentId) {
+      url = `/api/memory/threads/${threadId}?agentId=${opts.agentId}`;
+    } else if (opts.networkId) {
+      url = `/api/memory/network/threads/${threadId}?networkId=${opts.networkId}`;
+    }
+    return this.request(url, { method: "DELETE" });
+  }
   /**
    * Saves messages to memory
    * @param params - Parameters containing messages to save
@@ -2798,10 +2869,17 @@ var MastraClient = class extends BaseResource {
   }
   /**
    * Retrieves all available tools
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing map of tool IDs to tool details
    */
-  getTools() {
-    return this.request("/api/tools");
+  getTools(runtimeContext) {
+    const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
+    const searchParams = new URLSearchParams();
+    if (runtimeContextParam) {
+      searchParams.set("runtimeContext", runtimeContextParam);
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/tools${queryString ? `?${queryString}` : ""}`);
   }
   /**
    * Gets a tool instance by ID
@@ -2811,27 +2889,19 @@ var MastraClient = class extends BaseResource {
   getTool(toolId) {
     return new Tool(this.options, toolId);
   }
-  /**
-   * Retrieves all available legacy workflows
-   * @returns Promise containing map of legacy workflow IDs to legacy workflow details
-   */
-  getLegacyWorkflows() {
-    return this.request("/api/workflows/legacy");
-  }
-  /**
-   * Gets a legacy workflow instance by ID
-   * @param workflowId - ID of the legacy workflow to retrieve
-   * @returns Legacy Workflow instance
-   */
-  getLegacyWorkflow(workflowId) {
-    return new LegacyWorkflow(this.options, workflowId);
-  }
   /**
    * Retrieves all available workflows
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing map of workflow IDs to workflow details
    */
-  getWorkflows() {
-    return this.request("/api/workflows");
+  getWorkflows(runtimeContext) {
+    const runtimeContextParam = base64RuntimeContext(parseClientRuntimeContext(runtimeContext));
+    const searchParams = new URLSearchParams();
+    if (runtimeContextParam) {
+      searchParams.set("runtimeContext", runtimeContextParam);
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/workflows${queryString ? `?${queryString}` : ""}`);
   }
   /**
    * Gets a workflow instance by ID
@@ -2999,13 +3069,6 @@ var MastraClient = class extends BaseResource {
       return this.request(`/api/telemetry`);
     }
   }
-  /**
-   * Retrieves all available networks
-   * @returns Promise containing map of network IDs to network details
-   */
-  getNetworks() {
-    return this.request("/api/networks");
-  }
   /**
    * Retrieves all available vNext networks
    * @returns Promise containing map of vNext network IDs to vNext network details
@@ -3013,14 +3076,6 @@ var MastraClient = class extends BaseResource {
   getVNextNetworks() {
     return this.request("/api/networks/v-next");
   }
-  /**
-   * Gets a network instance by ID
-   * @param networkId - ID of the network to retrieve
-   * @returns Network instance
-   */
-  getNetwork(networkId) {
-    return new Network(this.options, networkId);
-  }
   /**
    * Gets a vNext network instance by ID
    * @param networkId - ID of the vNext network to retrieve
@@ -3211,8 +3266,30 @@ var MastraClient = class extends BaseResource {
   getAITraces(params) {
     return this.observability.getTraces(params);
   }
+  score(params) {
+    return this.observability.score(params);
+  }
+};
+
+// src/tools.ts
+var ClientTool = class {
+  id;
+  description;
+  inputSchema;
+  outputSchema;
+  execute;
+  constructor(opts) {
+    this.id = opts.id;
+    this.description = opts.description;
+    this.inputSchema = opts.inputSchema;
+    this.outputSchema = opts.outputSchema;
+    this.execute = opts.execute;
+  }
 };
+function createTool(opts) {
+  return new ClientTool(opts);
+}
 
-export { MastraClient };
+export { ClientTool, MastraClient, createTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map