@mastra/client-js 0.0.0-message-file-url-handling-fix-20250904234524 → 0.0.0-model-router-unknown-provider-20251017212006

package/dist/index.cjs

@@ -21,6 +21,20 @@ function parseClientRuntimeContext(runtimeContext$1) {
   }
   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";
 }
@@ -32,7 +46,7 @@ function zodToJsonSchema(zodSchema) {
     const fn = "toJSONSchema";
     return zod.z[fn].call(zod.z, zodSchema);
   }
-  return originalZodToJsonSchema__default.default(zodSchema, { $refStrategy: "none" });
+  return originalZodToJsonSchema__default.default(zodSchema, { $refStrategy: "relative" });
 }
 
 // src/utils/process-client-tools.ts
@@ -65,7 +79,7 @@ function processClientTools(clientTools) {
 }
 
 // src/utils/process-mastra-stream.ts
-async function processMastraStream({
+async function sharedProcessMastraStream({
   stream,
   onChunk
 }) {
@@ -83,7 +97,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 {
@@ -99,6 +113,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 {
@@ -187,7 +219,9 @@ async function executeToolCallAndRespond({
             resourceId,
             threadId,
             runtimeContext,
-            tracingContext: { currentSpan: void 0 }
+            tracingContext: { currentSpan: void 0 },
+            suspend: async () => {
+            }
           },
           {
             messages: response.messages,
@@ -195,11 +229,7 @@ async function executeToolCallAndRespond({
           }
         );
         const updatedMessages = [
-          {
-            role: "user",
-            content: params.messages
-          },
-          ...response.response.messages,
+          ...response.response.messages || [],
           {
             role: "tool",
             content: [
@@ -261,17 +291,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 {
@@ -283,16 +317,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 = {
@@ -325,7 +354,9 @@ var Agent = class extends BaseResource {
               resourceId,
               threadId,
               runtimeContext,
-              tracingContext: { currentSpan: void 0 }
+              tracingContext: { currentSpan: void 0 },
+              suspend: async () => {
+              }
             },
             {
               messages: response.messages,
@@ -333,10 +364,6 @@ var Agent = class extends BaseResource {
             }
           );
           const updatedMessages = [
-            {
-              role: "user",
-              content: params.messages
-            },
             ...response.response.messages,
             {
               role: "tool",
@@ -359,16 +386,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
@@ -382,7 +422,7 @@ var Agent = class extends BaseResource {
         resourceId,
         threadId,
         runtimeContext,
-        respondFn: this.generateVNext.bind(this)
+        respondFn: this.generate.bind(this)
       });
     }
     return response;
@@ -649,17 +689,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 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
@@ -674,7 +703,7 @@ var Agent = class extends BaseResource {
       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,
@@ -761,6 +790,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;
@@ -869,7 +906,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);
@@ -923,14 +960,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;
             }
@@ -941,8 +978,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) {
+    const response = await this.request(`/api/agents/${this.agentId}/stream`, {
       method: "POST",
       body: processedParams,
       stream: true
@@ -954,9 +991,27 @@ 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) {
+            let writer;
+            try {
+              writer = writable.getWriter();
+              const text = new TextDecoder().decode(chunk);
+              const lines = text.split("\n\n");
+              const readableLines = lines.filter((line) => line !== "[DONE]").join("\n\n");
+              await writer.write(new TextEncoder().encode(readableLines));
+            } catch {
+              await writer?.write(chunk);
+            } finally {
+              writer?.releaseLock();
+            }
+          }
+        }),
+        {
+          preventClose: true
+        }
+      ).catch((error) => {
         console.error("Error piping to writable stream:", error);
       });
       this.processChatResponse_vNext({
@@ -975,9 +1030,11 @@ var Agent = class extends BaseResource {
             if (toolCall) {
               toolCalls.push(toolCall);
             }
+            let shouldExecuteClientTool = false;
             for (const toolCall2 of toolCalls) {
               const clientTool = processedParams.clientTools?.[toolCall2.toolName];
               if (clientTool && clientTool.execute) {
+                shouldExecuteClientTool = true;
                 const result = await clientTool.execute(
                   {
                     context: toolCall2?.args,
@@ -986,14 +1043,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
                 );
@@ -1011,25 +1071,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];
-                this.processStreamResponse_vNext(
+                const updatedMessages = lastMessage != null ? [...messages.filter((m) => m.id !== lastMessage.id), lastMessage] : [...messages];
+                this.processStreamResponse(
                   {
                     ...processedParams,
-                    messages: [...messageArray, ...messages.filter((m) => m.id !== lastMessage.id), lastMessage]
+                    messages: updatedMessages
                   },
                   writable
                 ).catch((error) => {
@@ -1037,6 +1083,11 @@ var Agent = class extends BaseResource {
                 });
               }
             }
+            if (!shouldExecuteClientTool) {
+              setTimeout(() => {
+                writable.close();
+              }, 0);
+            }
           } else {
             setTimeout(() => {
               writable.close();
@@ -1052,15 +1103,52 @@ 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);
+    const response = await this.processStreamResponse(processedParams, writable);
     const streamResponse = new Response(readable, {
       status: response.status,
       statusText: response.statusText,
@@ -1079,7 +1167,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,
@@ -1124,7 +1212,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,
@@ -1162,12 +1252,10 @@ var Agent = class extends BaseResource {
                 } finally {
                   writer.releaseLock();
                 }
-                const originalMessages = processedParams.messages;
-                const messageArray = Array.isArray(originalMessages) ? originalMessages : [originalMessages];
-                this.processStreamResponse(
+                this.processStreamResponseLegacy(
                   {
                     ...processedParams,
-                    messages: [...messageArray, ...messages.filter((m) => m.id !== lastMessage.id), lastMessage]
+                    messages: [...messages.filter((m) => m.id !== lastMessage.id), lastMessage]
                   },
                   writable
                 ).catch((error) => {
@@ -1193,10 +1281,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
@@ -1207,7 +1296,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",
@@ -1216,17 +1305,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
@@ -1239,61 +1330,33 @@ 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 uiUtils.processDataStream({
-        stream: response.body,
-        ...options
-      });
-    };
-    return response;
+  }
+  async generateVNext(_messagesOrParams, _options) {
+    throw new Error("generateVNext has been renamed to generate. Please use generate instead.");
+  }
+  async streamVNext(_messagesOrParams, _options) {
+    throw new Error("streamVNext has been renamed to stream. Please use stream instead.");
   }
 };
 
@@ -1384,10 +1447,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
@@ -1401,10 +1467,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
@@ -1441,123 +1508,50 @@ var Vector = class extends BaseResource {
   }
 };
 
-// src/resources/legacy-workflow.ts
-var RECORD_SEPARATOR = "";
-var LegacyWorkflow = class extends BaseResource {
-  constructor(options, workflowId) {
+// src/resources/tool.ts
+var Tool = class extends BaseResource {
+  constructor(options, toolId) {
     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
-    });
+    this.toolId = toolId;
   }
   /**
-   * 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
+   * Retrieves details about the tool
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @returns Promise containing tool details including description and schemas
    */
-  resume({
-    stepId,
-    runId,
-    context
-  }) {
-    return this.request(`/api/workflows/legacy/${this.workflowId}/resume?runId=${runId}`, {
-      method: "POST",
-      body: {
-        stepId,
-        context
-      }
-    });
+  details(runtimeContext) {
+    return this.request(`/api/tools/${this.toolId}${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
-   * 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
+   * Executes the tool with the provided parameters
+   * @param params - Parameters required for tool execution
+   * @returns Promise containing the tool execution results
    */
-  startAsync(params) {
-    const searchParams = new URLSearchParams();
-    if (!!params?.runId) {
-      searchParams.set("runId", params.runId);
+  execute(params) {
+    const url = new URLSearchParams();
+    if (params.runId) {
+      url.set("runId", params.runId);
     }
-    return this.request(`/api/workflows/legacy/${this.workflowId}/start-async?${searchParams.toString()}`, {
+    const body = {
+      data: params.data,
+      runtimeContext: parseClientRuntimeContext(params.runtimeContext)
+    };
+    return this.request(`/api/tools/${this.toolId}/execute?${url.toString()}`, {
       method: "POST",
-      body: params?.triggerData
+      body
     });
   }
-  /**
-   * Resumes a suspended 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
-      }
-    });
+};
+
+// src/resources/workflow.ts
+var RECORD_SEPARATOR = "";
+var Workflow = class extends BaseResource {
+  constructor(options, workflowId) {
+    super(options);
+    this.workflowId = workflowId;
   }
   /**
-   * Creates an async generator that processes a readable stream and yields records
+   * Creates an async generator that processes a readable stream and yields workflow records
    * separated by the Record Separator character (\x1E)
    *
    * @param stream - The readable stream to process
@@ -1602,125 +1596,21 @@ var LegacyWorkflow = class extends BaseResource {
     }
   }
   /**
-   * 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) {
-    super(options);
-    this.toolId = toolId;
-  }
-  /**
-   * Retrieves details about the tool
-   * @returns Promise containing tool details including description and schemas
+   * 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/tools/${this.toolId}`);
+  details(runtimeContext) {
+    return this.request(`/api/workflows/${this.workflowId}${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
-   * Executes the tool with the provided parameters
-   * @param params - Parameters required for tool execution
-   * @returns Promise containing the tool execution results
+   * 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
    */
-  execute(params) {
-    const url = new URLSearchParams();
-    if (params.runId) {
-      url.set("runId", params.runId);
-    }
-    const body = {
-      data: params.data,
-      runtimeContext: parseClientRuntimeContext(params.runtimeContext)
-    };
-    return this.request(`/api/tools/${this.toolId}/execute?${url.toString()}`, {
-      method: "POST",
-      body
-    });
-  }
-};
-
-// src/resources/workflow.ts
-var RECORD_SEPARATOR2 = "";
-var Workflow = class extends BaseResource {
-  constructor(options, workflowId) {
-    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_SEPARATOR2);
-          buffer = chunks.pop() || "";
-          for (const chunk of chunks) {
-            if (chunk) {
-              if (typeof chunk === "string") {
-                try {
-                  const parsedChunk = JSON.parse(chunk);
-                  yield parsedChunk;
-                } catch {
-                }
-              }
-            }
-          }
-        } catch {
-        }
-      }
-      if (buffer) {
-        try {
-          yield JSON.parse(buffer);
-        } catch {
-        }
-      }
-    } finally {
-      reader.cancel().catch(() => {
-      });
-    }
-  }
-  /**
-   * Retrieves details about the workflow
-   * @returns Promise containing workflow details including steps and graphs
-   */
-  details() {
-    return this.request(`/api/workflows/${this.workflowId}`);
-  }
-  /**
-   * Retrieves all runs for a workflow
-   * @param params - Parameters for filtering runs
-   * @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());
@@ -1737,6 +1627,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 {
@@ -1746,18 +1639,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
@@ -1780,27 +1677,83 @@ 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,
+          tracingOptions: p.tracingOptions
+        });
+      },
+      startAsync: async (p) => {
+        return this.startAsync({
+          runId,
+          inputData: p.inputData,
+          runtimeContext: p.runtimeContext,
+          tracingOptions: p.tracingOptions
+        });
+      },
+      watch: async (onRecord) => {
+        return this.watch({ runId }, onRecord);
+      },
+      stream: async (p) => {
+        return this.stream({ runId, inputData: p.inputData, runtimeContext: p.runtimeContext });
+      },
+      resume: async (p) => {
+        return this.resume({
+          runId,
+          step: p.step,
+          resumeData: p.resumeData,
+          runtimeContext: p.runtimeContext,
+          tracingOptions: p.tracingOptions
+        });
+      },
+      resumeAsync: async (p) => {
+        return this.resumeAsync({
+          runId,
+          step: p.step,
+          resumeData: p.resumeData,
+          runtimeContext: p.runtimeContext,
+          tracingOptions: p.tracingOptions
+        });
+      },
+      resumeStreamVNext: async (p) => {
+        return this.resumeStreamVNext({
+          runId,
+          step: p.step,
+          resumeData: p.resumeData,
+          runtimeContext: p.runtimeContext
+        });
+      }
+    };
   }
   /**
    * Starts a workflow run synchronously without waiting for the workflow to complete
@@ -1811,7 +1764,7 @@ var Workflow = class extends BaseResource {
     const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
     return this.request(`/api/workflows/${this.workflowId}/start?runId=${params.runId}`, {
       method: "POST",
-      body: { inputData: params?.inputData, runtimeContext }
+      body: { inputData: params?.inputData, runtimeContext, tracingOptions: params.tracingOptions }
     });
   }
   /**
@@ -1823,16 +1776,17 @@ var Workflow = class extends BaseResource {
     step,
     runId,
     resumeData,
+    tracingOptions,
     ...rest
   }) {
     const runtimeContext = parseClientRuntimeContext(rest.runtimeContext);
     return this.request(`/api/workflows/${this.workflowId}/resume?runId=${runId}`, {
       method: "POST",
-      stream: true,
       body: {
         step,
         resumeData,
-        runtimeContext
+        runtimeContext,
+        tracingOptions
       }
     });
   }
@@ -1849,7 +1803,7 @@ var Workflow = class extends BaseResource {
     const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
     return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
       method: "POST",
-      body: { inputData: params.inputData, runtimeContext }
+      body: { inputData: params.inputData, runtimeContext, tracingOptions: params.tracingOptions }
     });
   }
   /**
@@ -1867,7 +1821,110 @@ var Workflow = class extends BaseResource {
       `/api/workflows/${this.workflowId}/stream?${searchParams.toString()}`,
       {
         method: "POST",
-        body: { inputData: params.inputData, runtimeContext },
+        body: { inputData: params.inputData, runtimeContext, tracingOptions: params.tracingOptions },
+        stream: true
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to stream workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
+  /**
+   * Observes workflow stream for a workflow run
+   * @param params - Object containing the runId
+   * @returns Promise containing the workflow execution results
+   */
+  async observeStream(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/observe-stream?${searchParams.toString()}`,
+      {
+        method: "POST",
+        stream: true
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to observe workflow stream: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
+  /**
+   * Starts a workflow run and returns a stream
+   * @param params - Object containing the optional runId, inputData and runtimeContext
+   * @returns Promise containing the workflow execution results
+   */
+  async streamVNext(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/streamVNext?${searchParams.toString()}`,
+      {
+        method: "POST",
+        body: {
+          inputData: params.inputData,
+          runtimeContext,
+          closeOnSuspend: params.closeOnSuspend,
+          tracingOptions: params.tracingOptions
+        },
         stream: true
       }
     );
@@ -1884,7 +1941,54 @@ 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;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
+  /**
+   * Observes workflow vNext stream for a workflow run
+   * @param params - Object containing the runId
+   * @returns Promise containing the workflow execution results
+   */
+  async observeStreamVNext(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/observe-streamVNext?${searchParams.toString()}`,
+      {
+        method: "POST",
+        stream: true
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to observe stream vNext workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
           for (const chunk2 of chunks) {
             if (chunk2) {
               const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
@@ -1915,10 +2019,65 @@ var Workflow = class extends BaseResource {
       body: {
         step: params.step,
         resumeData: params.resumeData,
-        runtimeContext
+        runtimeContext,
+        tracingOptions: params.tracingOptions
       }
     });
   }
+  /**
+   * Resumes a suspended workflow step that uses streamVNext asynchronously and returns a promise that resolves when the workflow is complete
+   * @param params - Object containing the runId, step, resumeData and runtimeContext
+   * @returns Promise containing the workflow resume results
+   */
+  async resumeStreamVNext(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/resume-stream?${searchParams.toString()}`,
+      {
+        method: "POST",
+        body: {
+          step: params.step,
+          resumeData: params.resumeData,
+          runtimeContext,
+          tracingOptions: params.tracingOptions
+        },
+        stream: true
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to stream vNext workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
   /**
    * Watches workflow transitions in real-time
    * @param runId - Optional run ID to filter the watch stream
@@ -1955,7 +2114,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();
@@ -2053,10 +2212,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.
@@ -2077,7 +2237,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);
@@ -2112,11 +2272,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);
@@ -2126,14 +2295,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`.
@@ -2216,7 +2377,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) {
@@ -2273,7 +2434,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;
@@ -2322,7 +2483,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;
@@ -2465,7 +2626,7 @@ var Observability = class extends BaseResource {
   getTraces(params) {
     const { pagination, filters } = params;
     const { page, perPage, dateRange } = pagination || {};
-    const { name, spanType } = filters || {};
+    const { name, spanType, entityId, entityType } = filters || {};
     const searchParams = new URLSearchParams();
     if (page !== void 0) {
       searchParams.set("page", String(page));
@@ -2479,6 +2640,10 @@ var Observability = class extends BaseResource {
     if (spanType !== void 0) {
       searchParams.set("spanType", String(spanType));
     }
+    if (entityId && entityType) {
+      searchParams.set("entityId", entityId);
+      searchParams.set("entityType", entityType);
+    }
     if (dateRange) {
       const dateRangeStr = JSON.stringify({
         start: dateRange.start instanceof Date ? dateRange.start.toISOString() : dateRange.start,
@@ -2489,6 +2654,31 @@ var Observability = class extends BaseResource {
     const queryString = searchParams.toString();
     return this.request(`/api/observability/traces${queryString ? `?${queryString}` : ""}`);
   }
+  /**
+   * Retrieves scores by trace ID and span ID
+   * @param params - Parameters containing trace ID, span ID, and pagination options
+   * @returns Promise containing scores and pagination info
+   */
+  getScoresBySpan(params) {
+    const { traceId, spanId, page, perPage } = params;
+    const searchParams = new URLSearchParams();
+    if (page !== void 0) {
+      searchParams.set("page", String(page));
+    }
+    if (perPage !== void 0) {
+      searchParams.set("perPage", String(perPage));
+    }
+    const queryString = searchParams.toString();
+    return this.request(
+      `/api/observability/traces/${encodeURIComponent(traceId)}/${encodeURIComponent(spanId)}/scores${queryString ? `?${queryString}` : ""}`
+    );
+  }
+  score(params) {
+    return this.request(`/api/observability/traces/score`, {
+      method: "POST",
+      body: { ...params }
+    });
+  }
 };
 
 // src/resources/network-memory-thread.ts
@@ -2554,144 +2744,6 @@ var NetworkMemoryThread = class extends BaseResource {
   }
 };
 
-// src/resources/vNextNetwork.ts
-var RECORD_SEPARATOR4 = "";
-var VNextNetwork = class extends BaseResource {
-  constructor(options, networkId) {
-    super(options);
-    this.networkId = networkId;
-  }
-  /**
-   * Retrieves details about the network
-   * @returns Promise containing vNext network details
-   */
-  details() {
-    return this.request(`/api/networks/v-next/${this.networkId}`);
-  }
-  /**
-   * Generates a response from the v-next network
-   * @param params - Generation parameters including message
-   * @returns Promise containing the generated response
-   */
-  generate(params) {
-    return this.request(`/api/networks/v-next/${this.networkId}/generate`, {
-      method: "POST",
-      body: {
-        ...params,
-        runtimeContext: parseClientRuntimeContext(params.runtimeContext)
-      }
-    });
-  }
-  /**
-   * Generates a response from the v-next network using multiple primitives
-   * @param params - Generation parameters including message
-   * @returns Promise containing the generated response
-   */
-  loop(params) {
-    return this.request(`/api/networks/v-next/${this.networkId}/loop`, {
-      method: "POST",
-      body: {
-        ...params,
-        runtimeContext: parseClientRuntimeContext(params.runtimeContext)
-      }
-    });
-  }
-  async *streamProcessor(stream) {
-    const reader = stream.getReader();
-    let doneReading = false;
-    let buffer = "";
-    try {
-      while (!doneReading) {
-        const { done, value } = await reader.read();
-        doneReading = done;
-        if (done && !value) continue;
-        try {
-          const decoded = value ? new TextDecoder().decode(value) : "";
-          const chunks = (buffer + decoded).split(RECORD_SEPARATOR4);
-          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;
@@ -2701,10 +2753,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
@@ -2722,6 +2781,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
@@ -2738,6 +2805,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
@@ -2800,10 +2885,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
@@ -2813,27 +2905,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
@@ -3001,36 +3085,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
-   */
-  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
-   * @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).
@@ -3135,7 +3189,7 @@ var MastraClient = class extends BaseResource {
    * @returns Promise containing the scorer
    */
   getScorer(scorerId) {
-    return this.request(`/api/scores/scorers/${scorerId}`);
+    return this.request(`/api/scores/scorers/${encodeURIComponent(scorerId)}`);
   }
   getScoresByScorerId(params) {
     const { page, perPage, scorerId, entityId, entityType } = params;
@@ -3153,7 +3207,7 @@ var MastraClient = class extends BaseResource {
       searchParams.set("perPage", String(perPage));
     }
     const queryString = searchParams.toString();
-    return this.request(`/api/scores/scorer/${scorerId}${queryString ? `?${queryString}` : ""}`);
+    return this.request(`/api/scores/scorer/${encodeURIComponent(scorerId)}${queryString ? `?${queryString}` : ""}`);
   }
   /**
    * Retrieves scores by run ID
@@ -3170,7 +3224,7 @@ var MastraClient = class extends BaseResource {
       searchParams.set("perPage", String(perPage));
     }
     const queryString = searchParams.toString();
-    return this.request(`/api/scores/run/${runId}${queryString ? `?${queryString}` : ""}`);
+    return this.request(`/api/scores/run/${encodeURIComponent(runId)}${queryString ? `?${queryString}` : ""}`);
   }
   /**
    * Retrieves scores by entity ID and type
@@ -3187,7 +3241,9 @@ var MastraClient = class extends BaseResource {
       searchParams.set("perPage", String(perPage));
     }
     const queryString = searchParams.toString();
-    return this.request(`/api/scores/entity/${entityType}/${entityId}${queryString ? `?${queryString}` : ""}`);
+    return this.request(
+      `/api/scores/entity/${encodeURIComponent(entityType)}/${encodeURIComponent(entityId)}${queryString ? `?${queryString}` : ""}`
+    );
   }
   /**
    * Saves a score
@@ -3213,8 +3269,35 @@ var MastraClient = class extends BaseResource {
   getAITraces(params) {
     return this.observability.getTraces(params);
   }
+  getScoresBySpan(params) {
+    return this.observability.getScoresBySpan(params);
+  }
+  score(params) {
+    return this.observability.score(params);
+  }
 };
 
+// src/tools.ts
+var ClientTool = class {
+  id;
+  description;
+  inputSchema;
+  outputSchema;
+  execute;
+  constructor(opts) {
+    this.id = opts.id;
+    this.description = opts.description;
+    this.inputSchema = opts.inputSchema;
+    this.outputSchema = opts.outputSchema;
+    this.execute = opts.execute;
+  }
+};
+function createTool(opts) {
+  return new ClientTool(opts);
+}
+
+exports.ClientTool = ClientTool;
 exports.MastraClient = MastraClient;
+exports.createTool = createTool;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map