@mastra/client-js 0.0.0-fix-zod-to-json-schema-ref-strategy-20250910193441 → 0.0.0-fix-cloud-peer-deps-20250923194656

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";
 }
@@ -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,
@@ -255,17 +289,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,14 +315,15 @@ 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}`);
+  details(runtimeContext) {
+    return this.request(`/api/agents/${this.agentId}${runtimeContextQueryString(runtimeContext)}`);
   }
   async generate(params) {
     console.warn(
-      "Deprecation NOTICE:Generate method will switch to use generateVNext implementation September 16th, 2025. Please use generateLegacy if you don't want to upgrade just yet."
+      "Deprecation NOTICE:Generate method will switch to use generateVNext implementation September 30th, 2025. Please use generateLegacy if you don't want to upgrade just yet."
     );
     return this.generateLegacy(params);
   }
@@ -319,7 +358,9 @@ var Agent = class extends BaseResource {
               resourceId,
               threadId,
               runtimeContext,
-              tracingContext: { currentSpan: void 0 }
+              tracingContext: { currentSpan: void 0 },
+              suspend: async () => {
+              }
             },
             {
               messages: response.messages,
@@ -353,7 +394,16 @@ var Agent = class extends BaseResource {
     }
     return response;
   }
-  async generateVNext(params) {
+  async generateVNext(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,
@@ -654,7 +704,7 @@ var Agent = class extends BaseResource {
    */
   async stream(params) {
     console.warn(
-      "Deprecation NOTICE:\nStream method will switch to use streamVNext implementation September 16th, 2025. Please use streamLegacy if you don't want to upgrade just yet."
+      "Deprecation NOTICE:\nStream method will switch to use streamVNext implementation September 30th, 2025. Please use streamLegacy if you don't want to upgrade just yet."
     );
     return this.streamLegacy(params);
   }
@@ -1003,7 +1053,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,
@@ -1058,7 +1110,40 @@ 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 streamVNext(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,
@@ -1134,7 +1219,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,
@@ -1203,10 +1290,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
@@ -1217,7 +1305,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",
@@ -1226,17 +1314,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
@@ -1249,61 +1339,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;
   }
 };
 
@@ -1394,10 +1450,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
@@ -1411,10 +1470,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
@@ -1460,17 +1520,20 @@ var LegacyWorkflow = class extends BaseResource {
   }
   /**
    * Retrieves details about the legacy workflow
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing legacy workflow details including steps and graphs
    */
-  details() {
-    return this.request(`/api/workflows/legacy/${this.workflowId}`);
+  details(runtimeContext) {
+    return this.request(`/api/workflows/legacy/${this.workflowId}${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
    * Retrieves all runs for a legacy workflow
    * @param params - Parameters for filtering runs
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing legacy 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());
@@ -1487,6 +1550,9 @@ var LegacyWorkflow = 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/legacy/${this.workflowId}/runs?${searchParams}`);
     } else {
@@ -1640,10 +1706,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
@@ -1720,17 +1787,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());
@@ -1747,6 +1817,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 {
@@ -1756,18 +1829,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
@@ -1790,27 +1867,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
@@ -1838,7 +1949,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,
@@ -1882,7 +1992,54 @@ var Workflow = class extends BaseResource {
       }
     );
     if (!response.ok) {
-      throw new Error(`Failed to stream vNext workflow: ${response.statusText}`);
+      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_SEPARATOR2);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
+  /**
+   * 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");
@@ -1928,7 +2085,7 @@ var Workflow = class extends BaseResource {
       `/api/workflows/${this.workflowId}/streamVNext?${searchParams.toString()}`,
       {
         method: "POST",
-        body: { inputData: params.inputData, runtimeContext },
+        body: { inputData: params.inputData, runtimeContext, closeOnSuspend: params.closeOnSuspend },
         stream: true
       }
     );
@@ -1980,6 +2137,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
@@ -2114,10 +2287,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.
@@ -2173,11 +2347,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);
@@ -2187,14 +2370,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`.
@@ -2554,6 +2729,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
@@ -2628,10 +2809,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
@@ -2766,10 +2948,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
@@ -2787,6 +2976,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
@@ -2803,6 +3000,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
@@ -2865,10 +3080,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
@@ -2895,10 +3117,17 @@ var MastraClient = class extends BaseResource {
   }
   /**
    * 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
@@ -3066,13 +3295,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
@@ -3080,14 +3302,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
@@ -3278,8 +3492,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