@mastra/client-js 0.0.0-consolidate-changesets-20250904042643 → 0.0.0-createToolOptions-20250926094418

package/dist/index.js

@@ -1,5 +1,3 @@
-import { AbstractAgent, EventType } from '@ag-ui/client';
-import { Observable } from 'rxjs';
 import { processDataStream, parsePartialJson } from '@ai-sdk/ui-utils';
 import { v4 } from '@lukeed/uuid';
 import { RuntimeContext } from '@mastra/core/runtime-context';
@@ -7,205 +5,7 @@ import { isVercelTool } from '@mastra/core/tools/is-vercel-tool';
 import { z } from 'zod';
 import originalZodToJsonSchema from 'zod-to-json-schema';
 
-// src/adapters/agui.ts
-var AGUIAdapter = class extends AbstractAgent {
-  agent;
-  resourceId;
-  constructor({ agent, agentId, resourceId, ...rest }) {
-    super({
-      agentId,
-      ...rest
-    });
-    this.agent = agent;
-    this.resourceId = resourceId;
-  }
-  run(input) {
-    return new Observable((subscriber) => {
-      const convertedMessages = convertMessagesToMastraMessages(input.messages);
-      subscriber.next({
-        type: EventType.RUN_STARTED,
-        threadId: input.threadId,
-        runId: input.runId
-      });
-      this.agent.stream({
-        threadId: input.threadId,
-        resourceId: this.resourceId ?? "",
-        runId: input.runId,
-        messages: convertedMessages,
-        clientTools: input.tools.reduce(
-          (acc, tool) => {
-            acc[tool.name] = {
-              id: tool.name,
-              description: tool.description,
-              inputSchema: tool.parameters
-            };
-            return acc;
-          },
-          {}
-        )
-      }).then((response) => {
-        let currentMessageId = void 0;
-        let isInTextMessage = false;
-        return response.processDataStream({
-          onTextPart: (text) => {
-            if (currentMessageId === void 0) {
-              currentMessageId = generateUUID();
-              const message2 = {
-                type: EventType.TEXT_MESSAGE_START,
-                messageId: currentMessageId,
-                role: "assistant"
-              };
-              subscriber.next(message2);
-              isInTextMessage = true;
-            }
-            const message = {
-              type: EventType.TEXT_MESSAGE_CONTENT,
-              messageId: currentMessageId,
-              delta: text
-            };
-            subscriber.next(message);
-          },
-          onFinishMessagePart: () => {
-            if (currentMessageId !== void 0) {
-              const message = {
-                type: EventType.TEXT_MESSAGE_END,
-                messageId: currentMessageId
-              };
-              subscriber.next(message);
-              isInTextMessage = false;
-            }
-            subscriber.next({
-              type: EventType.RUN_FINISHED,
-              threadId: input.threadId,
-              runId: input.runId
-            });
-            subscriber.complete();
-          },
-          onToolCallPart(streamPart) {
-            const parentMessageId = currentMessageId || generateUUID();
-            if (isInTextMessage) {
-              const message = {
-                type: EventType.TEXT_MESSAGE_END,
-                messageId: parentMessageId
-              };
-              subscriber.next(message);
-              isInTextMessage = false;
-            }
-            subscriber.next({
-              type: EventType.TOOL_CALL_START,
-              toolCallId: streamPart.toolCallId,
-              toolCallName: streamPart.toolName,
-              parentMessageId
-            });
-            subscriber.next({
-              type: EventType.TOOL_CALL_ARGS,
-              toolCallId: streamPart.toolCallId,
-              delta: JSON.stringify(streamPart.args),
-              parentMessageId
-            });
-            subscriber.next({
-              type: EventType.TOOL_CALL_END,
-              toolCallId: streamPart.toolCallId,
-              parentMessageId
-            });
-          }
-        });
-      }).catch((error) => {
-        console.error("error", error);
-        subscriber.error(error);
-      });
-      return () => {
-      };
-    });
-  }
-};
-function generateUUID() {
-  if (typeof crypto !== "undefined") {
-    if (typeof crypto.randomUUID === "function") {
-      return crypto.randomUUID();
-    }
-    if (typeof crypto.getRandomValues === "function") {
-      const buffer = new Uint8Array(16);
-      crypto.getRandomValues(buffer);
-      buffer[6] = buffer[6] & 15 | 64;
-      buffer[8] = buffer[8] & 63 | 128;
-      let hex = "";
-      for (let i = 0; i < 16; i++) {
-        hex += buffer[i].toString(16).padStart(2, "0");
-        if (i === 3 || i === 5 || i === 7 || i === 9) hex += "-";
-      }
-      return hex;
-    }
-  }
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = Math.random() * 16 | 0;
-    const v = c === "x" ? r : r & 3 | 8;
-    return v.toString(16);
-  });
-}
-function convertMessagesToMastraMessages(messages) {
-  const result = [];
-  const toolCallsWithResults = /* @__PURE__ */ new Set();
-  for (const message of messages) {
-    if (message.role === "tool" && message.toolCallId) {
-      toolCallsWithResults.add(message.toolCallId);
-    }
-  }
-  for (const message of messages) {
-    if (message.role === "assistant") {
-      const parts = message.content ? [{ type: "text", text: message.content }] : [];
-      for (const toolCall of message.toolCalls ?? []) {
-        parts.push({
-          type: "tool-call",
-          toolCallId: toolCall.id,
-          toolName: toolCall.function.name,
-          args: JSON.parse(toolCall.function.arguments)
-        });
-      }
-      result.push({
-        role: "assistant",
-        content: parts
-      });
-      if (message.toolCalls?.length) {
-        for (const toolCall of message.toolCalls) {
-          if (!toolCallsWithResults.has(toolCall.id)) {
-            result.push({
-              role: "tool",
-              content: [
-                {
-                  type: "tool-result",
-                  toolCallId: toolCall.id,
-                  toolName: toolCall.function.name,
-                  result: JSON.parse(toolCall.function.arguments)
-                  // This is still wrong but matches test expectations
-                }
-              ]
-            });
-          }
-        }
-      }
-    } else if (message.role === "user") {
-      result.push({
-        role: "user",
-        content: message.content || ""
-      });
-    } else if (message.role === "tool") {
-      result.push({
-        role: "tool",
-        content: [
-          {
-            type: "tool-result",
-            toolCallId: message.toolCallId || "unknown",
-            toolName: "unknown",
-            // toolName is not available in tool messages from CopilotKit
-            result: message.content
-          }
-        ]
-      });
-    }
-  }
-  return result;
-}
+// src/resources/agent.ts
 function parseClientRuntimeContext(runtimeContext) {
   if (runtimeContext) {
     if (runtimeContext instanceof RuntimeContext) {
@@ -215,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";
 }
@@ -226,7 +40,7 @@ function zodToJsonSchema(zodSchema) {
     const fn = "toJSONSchema";
     return z[fn].call(z, zodSchema);
   }
-  return originalZodToJsonSchema(zodSchema, { $refStrategy: "none" });
+  return originalZodToJsonSchema(zodSchema, { $refStrategy: "relative" });
 }
 
 // src/utils/process-client-tools.ts
@@ -259,7 +73,7 @@ function processClientTools(clientTools) {
 }
 
 // src/utils/process-mastra-stream.ts
-async function processMastraStream({
+async function sharedProcessMastraStream({
   stream,
   onChunk
 }) {
@@ -277,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 {
@@ -293,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 {
@@ -381,7 +213,9 @@ async function executeToolCallAndRespond({
             resourceId,
             threadId,
             runtimeContext,
-            tracingContext: { currentSpan: void 0 }
+            tracingContext: { currentSpan: void 0 },
+            suspend: async () => {
+            }
           },
           {
             messages: response.messages,
@@ -389,11 +223,7 @@ async function executeToolCallAndRespond({
           }
         );
         const updatedMessages = [
-          {
-            role: "user",
-            content: params.messages
-          },
-          ...response.response.messages,
+          ...response.response.messages || [],
           {
             role: "tool",
             content: [
@@ -455,17 +285,21 @@ var AgentVoice = class extends BaseResource {
   }
   /**
    * Get available speakers for the agent's voice provider
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing list of available speakers
    */
-  getSpeakers() {
-    return this.request(`/api/agents/${this.agentId}/voice/speakers`);
+  getSpeakers(runtimeContext) {
+    return this.request(`/api/agents/${this.agentId}/voice/speakers${runtimeContextQueryString(runtimeContext)}`);
   }
   /**
    * Get the listener configuration for the agent's voice provider
+   * @param runtimeContext - Optional runtime context to pass as query parameter
+   * @param runtimeContext - Optional runtime context to pass as query parameter
    * @returns Promise containing a check if the agent has listening capabilities
    */
-  getListener() {
-    return this.request(`/api/agents/${this.agentId}/voice/listener`);
+  getListener(runtimeContext) {
+    return this.request(`/api/agents/${this.agentId}/voice/listener${runtimeContextQueryString(runtimeContext)}`);
   }
 };
 var Agent = class extends BaseResource {
@@ -477,14 +311,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. 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);
   }
@@ -519,7 +354,9 @@ var Agent = class extends BaseResource {
               resourceId,
               threadId,
               runtimeContext,
-              tracingContext: { currentSpan: void 0 }
+              tracingContext: { currentSpan: void 0 },
+              suspend: async () => {
+              }
             },
             {
               messages: response.messages,
@@ -527,10 +364,6 @@ var Agent = class extends BaseResource {
             }
           );
           const updatedMessages = [
-            {
-              role: "user",
-              content: params.messages
-            },
             ...response.response.messages,
             {
               role: "tool",
@@ -553,12 +386,25 @@ 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,
       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(
@@ -850,7 +696,7 @@ var Agent = class extends BaseResource {
    */
   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."
+      "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);
   }
@@ -1063,7 +909,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);
@@ -1117,14 +963,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;
             }
@@ -1148,9 +994,28 @@ var Agent = class extends BaseResource {
       let toolCalls = [];
       let messages = [];
       const [streamForWritable, streamForProcessing] = response.body.tee();
-      streamForWritable.pipeTo(writable, {
-        preventClose: true
-      }).catch((error) => {
+      streamForWritable.pipeTo(
+        new WritableStream({
+          async write(chunk) {
+            try {
+              const text = new TextDecoder().decode(chunk);
+              if (text.includes("[DONE]")) {
+                return;
+              }
+            } catch {
+            }
+            const writer = writable.getWriter();
+            try {
+              await writer.write(chunk);
+            } finally {
+              writer.releaseLock();
+            }
+          }
+        }),
+        {
+          preventClose: true
+        }
+      ).catch((error) => {
         console.error("Error piping to writable stream:", error);
       });
       this.processChatResponse_vNext({
@@ -1180,14 +1045,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
                 );
@@ -1205,25 +1073,11 @@ var Agent = class extends BaseResource {
                   toolInvocation.state = "result";
                   toolInvocation.result = result;
                 }
-                const writer = writable.getWriter();
-                try {
-                  await writer.write(
-                    new TextEncoder().encode(
-                      "a:" + JSON.stringify({
-                        toolCallId: toolCall2.toolCallId,
-                        result
-                      }) + "\n"
-                    )
-                  );
-                } finally {
-                  writer.releaseLock();
-                }
-                const originalMessages = processedParams.messages;
-                const messageArray = Array.isArray(originalMessages) ? originalMessages : [originalMessages];
+                const updatedMessages = lastMessage != null ? [...messages.filter((m) => m.id !== lastMessage.id), lastMessage] : [...messages];
                 this.processStreamResponse_vNext(
                   {
                     ...processedParams,
-                    messages: [...messageArray, ...messages.filter((m) => m.id !== lastMessage.id), lastMessage]
+                    messages: updatedMessages
                   },
                   writable
                 ).catch((error) => {
@@ -1246,12 +1100,49 @@ var Agent = class extends BaseResource {
     }
     return response;
   }
-  async streamVNext(params) {
+  async network(params) {
+    const response = await this.request(`/api/agents/${this.agentId}/network`, {
+      method: "POST",
+      body: params,
+      stream: true
+    });
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    const streamResponse = new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    streamResponse.processDataStream = async ({
+      onChunk
+    }) => {
+      await processMastraNetworkStream({
+        stream: streamResponse.body,
+        onChunk
+      });
+    };
+    return streamResponse;
+  }
+  async 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,
       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);
@@ -1318,7 +1209,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,
@@ -1356,12 +1249,10 @@ var Agent = class extends BaseResource {
                 } finally {
                   writer.releaseLock();
                 }
-                const originalMessages = processedParams.messages;
-                const messageArray = Array.isArray(originalMessages) ? originalMessages : [originalMessages];
                 this.processStreamResponse(
                   {
                     ...processedParams,
-                    messages: [...messageArray, ...messages.filter((m) => m.id !== lastMessage.id), lastMessage]
+                    messages: [...messages.filter((m) => m.id !== lastMessage.id), lastMessage]
                   },
                   writable
                 ).catch((error) => {
@@ -1387,10 +1278,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
@@ -1401,7 +1293,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",
@@ -1410,17 +1302,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
@@ -1433,61 +1327,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;
   }
 };
 
@@ -1578,10 +1438,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
@@ -1595,10 +1458,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
@@ -1635,187 +1499,6 @@ var Vector = class extends BaseResource {
   }
 };
 
-// src/resources/legacy-workflow.ts
-var RECORD_SEPARATOR = "";
-var LegacyWorkflow = class extends BaseResource {
-  constructor(options, workflowId) {
-    super(options);
-    this.workflowId = workflowId;
-  }
-  /**
-   * Retrieves details about the legacy workflow
-   * @returns Promise containing legacy workflow details including steps and graphs
-   */
-  details() {
-    return this.request(`/api/workflows/legacy/${this.workflowId}`);
-  }
-  /**
-   * Retrieves all runs for a legacy workflow
-   * @param params - Parameters for filtering runs
-   * @returns Promise containing legacy workflow runs array
-   */
-  runs(params) {
-    const searchParams = new URLSearchParams();
-    if (params?.fromDate) {
-      searchParams.set("fromDate", params.fromDate.toISOString());
-    }
-    if (params?.toDate) {
-      searchParams.set("toDate", params.toDate.toISOString());
-    }
-    if (params?.limit) {
-      searchParams.set("limit", String(params.limit));
-    }
-    if (params?.offset) {
-      searchParams.set("offset", String(params.offset));
-    }
-    if (params?.resourceId) {
-      searchParams.set("resourceId", params.resourceId);
-    }
-    if (searchParams.size) {
-      return this.request(`/api/workflows/legacy/${this.workflowId}/runs?${searchParams}`);
-    } else {
-      return this.request(`/api/workflows/legacy/${this.workflowId}/runs`);
-    }
-  }
-  /**
-   * Creates a new legacy workflow run
-   * @returns Promise containing the generated run ID
-   */
-  createRun(params) {
-    const searchParams = new URLSearchParams();
-    if (!!params?.runId) {
-      searchParams.set("runId", params.runId);
-    }
-    return this.request(`/api/workflows/legacy/${this.workflowId}/create-run?${searchParams.toString()}`, {
-      method: "POST"
-    });
-  }
-  /**
-   * Starts a legacy workflow run synchronously without waiting for the workflow to complete
-   * @param params - Object containing the runId and triggerData
-   * @returns Promise containing success message
-   */
-  start(params) {
-    return this.request(`/api/workflows/legacy/${this.workflowId}/start?runId=${params.runId}`, {
-      method: "POST",
-      body: params?.triggerData
-    });
-  }
-  /**
-   * Resumes a suspended legacy workflow step synchronously without waiting for the workflow to complete
-   * @param stepId - ID of the step to resume
-   * @param runId - ID of the legacy workflow run
-   * @param context - Context to resume the legacy workflow with
-   * @returns Promise containing the legacy workflow resume results
-   */
-  resume({
-    stepId,
-    runId,
-    context
-  }) {
-    return this.request(`/api/workflows/legacy/${this.workflowId}/resume?runId=${runId}`, {
-      method: "POST",
-      body: {
-        stepId,
-        context
-      }
-    });
-  }
-  /**
-   * Starts a workflow run asynchronously and returns a promise that resolves when the workflow is complete
-   * @param params - Object containing the optional runId and triggerData
-   * @returns Promise containing the workflow execution results
-   */
-  startAsync(params) {
-    const searchParams = new URLSearchParams();
-    if (!!params?.runId) {
-      searchParams.set("runId", params.runId);
-    }
-    return this.request(`/api/workflows/legacy/${this.workflowId}/start-async?${searchParams.toString()}`, {
-      method: "POST",
-      body: params?.triggerData
-    });
-  }
-  /**
-   * Resumes a suspended legacy workflow step asynchronously and returns a promise that resolves when the workflow is complete
-   * @param params - Object containing the runId, stepId, and context
-   * @returns Promise containing the workflow resume results
-   */
-  resumeAsync(params) {
-    return this.request(`/api/workflows/legacy/${this.workflowId}/resume-async?runId=${params.runId}`, {
-      method: "POST",
-      body: {
-        stepId: params.stepId,
-        context: params.context
-      }
-    });
-  }
-  /**
-   * Creates an async generator that processes a readable stream and yields records
-   * separated by the Record Separator character (\x1E)
-   *
-   * @param stream - The readable stream to process
-   * @returns An async generator that yields parsed records
-   */
-  async *streamProcessor(stream) {
-    const reader = stream.getReader();
-    let doneReading = false;
-    let buffer = "";
-    try {
-      while (!doneReading) {
-        const { done, value } = await reader.read();
-        doneReading = done;
-        if (done && !value) continue;
-        try {
-          const decoded = value ? new TextDecoder().decode(value) : "";
-          const chunks = (buffer + decoded).split(RECORD_SEPARATOR);
-          buffer = chunks.pop() || "";
-          for (const chunk of chunks) {
-            if (chunk) {
-              if (typeof chunk === "string") {
-                try {
-                  const parsedChunk = JSON.parse(chunk);
-                  yield parsedChunk;
-                } catch {
-                }
-              }
-            }
-          }
-        } catch {
-        }
-      }
-      if (buffer) {
-        try {
-          yield JSON.parse(buffer);
-        } catch {
-        }
-      }
-    } finally {
-      reader.cancel().catch(() => {
-      });
-    }
-  }
-  /**
-   * Watches legacy workflow transitions in real-time
-   * @param runId - Optional run ID to filter the watch stream
-   * @returns AsyncGenerator that yields parsed records from the legacy workflow watch stream
-   */
-  async watch({ runId }, onRecord) {
-    const response = await this.request(`/api/workflows/legacy/${this.workflowId}/watch?runId=${runId}`, {
-      stream: true
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to watch legacy workflow: ${response.statusText}`);
-    }
-    if (!response.body) {
-      throw new Error("Response body is null");
-    }
-    for await (const record of this.streamProcessor(response.body)) {
-      onRecord(record);
-    }
-  }
-};
-
 // src/resources/tool.ts
 var Tool = class extends BaseResource {
   constructor(options, toolId) {
@@ -1824,10 +1507,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
@@ -1851,7 +1535,7 @@ var Tool = class extends BaseResource {
 };
 
 // src/resources/workflow.ts
-var RECORD_SEPARATOR2 = "";
+var RECORD_SEPARATOR = "";
 var Workflow = class extends BaseResource {
   constructor(options, workflowId) {
     super(options);
@@ -1875,7 +1559,7 @@ var Workflow = class extends BaseResource {
         if (done && !value) continue;
         try {
           const decoded = value ? new TextDecoder().decode(value) : "";
-          const chunks = (buffer + decoded).split(RECORD_SEPARATOR2);
+          const chunks = (buffer + decoded).split(RECORD_SEPARATOR);
           buffer = chunks.pop() || "";
           for (const chunk of chunks) {
             if (chunk) {
@@ -1904,17 +1588,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());
@@ -1931,6 +1618,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 {
@@ -1940,18 +1630,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
@@ -1974,27 +1668,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
@@ -2022,7 +1750,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,
@@ -2065,6 +1792,104 @@ var Workflow = class extends BaseResource {
         stream: true
       }
     );
+    if (!response.ok) {
+      throw new Error(`Failed to stream workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
+  /**
+   * Observes workflow stream for a workflow run
+   * @param params - Object containing the runId
+   * @returns Promise containing the workflow execution results
+   */
+  async observeStream(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", params.runId);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/observe-stream?${searchParams.toString()}`,
+      {
+        method: "POST",
+        stream: true
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to observe workflow stream: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    let failedChunk = void 0;
+    const transformStream = new TransformStream({
+      start() {
+      },
+      async transform(chunk, controller) {
+        try {
+          const decoded = new TextDecoder().decode(chunk);
+          const chunks = decoded.split(RECORD_SEPARATOR);
+          for (const chunk2 of chunks) {
+            if (chunk2) {
+              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
+              try {
+                const parsedChunk = JSON.parse(newChunk);
+                controller.enqueue(parsedChunk);
+                failedChunk = void 0;
+              } catch {
+                failedChunk = newChunk;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    return response.body.pipeThrough(transformStream);
+  }
+  /**
+   * Starts a workflow run and returns a stream
+   * @param params - Object containing the optional runId, inputData and runtimeContext
+   * @returns Promise containing the workflow execution results
+   */
+  async streamVNext(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/streamVNext?${searchParams.toString()}`,
+      {
+        method: "POST",
+        body: { inputData: params.inputData, runtimeContext, closeOnSuspend: params.closeOnSuspend },
+        stream: true
+      }
+    );
     if (!response.ok) {
       throw new Error(`Failed to stream vNext workflow: ${response.statusText}`);
     }
@@ -2078,7 +1903,7 @@ var Workflow = class extends BaseResource {
       async transform(chunk, controller) {
         try {
           const decoded = new TextDecoder().decode(chunk);
-          const chunks = decoded.split(RECORD_SEPARATOR2);
+          const chunks = decoded.split(RECORD_SEPARATOR);
           for (const chunk2 of chunks) {
             if (chunk2) {
               const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
@@ -2113,6 +1938,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
@@ -2149,7 +1990,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();
@@ -2247,10 +2088,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.
@@ -2271,7 +2113,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);
@@ -2306,21 +2148,27 @@ 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, runId) {
+  async createRunAsync(params) {
     const searchParams = new URLSearchParams();
-    if (runId) {
-      searchParams.set("runId", runId);
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
     }
-    const runtimeContext = parseClientRuntimeContext(params.runtimeContext);
-    const { runtimeContext: _, ...actionParams } = params;
     const url = `/api/agent-builder/${this.actionId}/create-run${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
     return this.request(url, {
-      method: "POST",
-      body: { ...actionParams, runtimeContext }
+      method: "POST"
     });
   }
   /**
@@ -2405,7 +2253,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) {
@@ -2462,7 +2310,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;
@@ -2511,7 +2359,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;
@@ -2536,8 +2384,8 @@ var AgentBuilder = class extends BaseResource {
    * and streams any remaining progress.
    * This calls `/api/agent-builder/:actionId/watch`.
    */
-  async watch({ runId }, onRecord) {
-    const url = `/api/agent-builder/${this.actionId}/watch?runId=${runId}`;
+  async watch({ runId, eventType }, onRecord) {
+    const url = `/api/agent-builder/${this.actionId}/watch?runId=${runId}${eventType ? `&eventType=${eventType}` : ""}`;
     const response = await this.request(url, {
       method: "GET",
       stream: true
@@ -2654,7 +2502,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));
@@ -2668,6 +2516,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,
@@ -2678,6 +2530,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
@@ -2744,7 +2602,7 @@ var NetworkMemoryThread = class extends BaseResource {
 };
 
 // src/resources/vNextNetwork.ts
-var RECORD_SEPARATOR4 = "";
+var RECORD_SEPARATOR3 = "";
 var VNextNetwork = class extends BaseResource {
   constructor(options, networkId) {
     super(options);
@@ -2752,10 +2610,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
@@ -2796,7 +2655,7 @@ var VNextNetwork = class extends BaseResource {
         if (done && !value) continue;
         try {
           const decoded = value ? new TextDecoder().decode(value) : "";
-          const chunks = (buffer + decoded).split(RECORD_SEPARATOR4);
+          const chunks = (buffer + decoded).split(RECORD_SEPARATOR3);
           buffer = chunks.pop() || "";
           for (const chunk of chunks) {
             if (chunk) {
@@ -2890,25 +2749,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");
-  }
-  async getAGUI({ resourceId }) {
-    const agents = await this.getAgents();
-    return Object.entries(agents).reduce(
-      (acc, [agentId]) => {
-        const agent = this.getAgent(agentId);
-        acc[agentId] = new AGUIAdapter({
-          agentId,
-          agent,
-          resourceId
-        });
-        return acc;
-      },
-      {}
-    );
+  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
@@ -2926,6 +2777,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
@@ -2942,6 +2801,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
@@ -3004,10 +2881,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
@@ -3017,27 +2901,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
@@ -3205,13 +3081,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
@@ -3219,14 +3088,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
@@ -3417,8 +3278,30 @@ var MastraClient = class extends BaseResource {
   getAITraces(params) {
     return this.observability.getTraces(params);
   }
+  score(params) {
+    return this.observability.score(params);
+  }
 };
 
-export { MastraClient };
+// 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 { ClientTool, MastraClient, createTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map