@mastra/client-js 1.0.0-beta.8 → 1.0.0

package/dist/index.cjs

@@ -1,13 +1,1103 @@
 'use strict';
 
-var uiUtils = require('@ai-sdk/ui-utils');
 var uuid = require('@lukeed/uuid');
 var error = require('@mastra/core/error');
 var requestContext = require('@mastra/core/request-context');
 var isVercelTool = require('@mastra/core/tools/is-vercel-tool');
 var zodToJson = require('@mastra/schema-compat/zod-to-json');
 
-// src/resources/agent.ts
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  mod
+));
+
+// ../../node_modules/.pnpm/secure-json-parse@2.7.0/node_modules/secure-json-parse/index.js
+var require_secure_json_parse = __commonJS({
+  "../../node_modules/.pnpm/secure-json-parse@2.7.0/node_modules/secure-json-parse/index.js"(exports, module) {
+    var hasBuffer = typeof Buffer !== "undefined";
+    var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+    var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+    function _parse(text, reviver, options) {
+      if (options == null) {
+        if (reviver !== null && typeof reviver === "object") {
+          options = reviver;
+          reviver = void 0;
+        }
+      }
+      if (hasBuffer && Buffer.isBuffer(text)) {
+        text = text.toString();
+      }
+      if (text && text.charCodeAt(0) === 65279) {
+        text = text.slice(1);
+      }
+      const obj = JSON.parse(text, reviver);
+      if (obj === null || typeof obj !== "object") {
+        return obj;
+      }
+      const protoAction = options && options.protoAction || "error";
+      const constructorAction = options && options.constructorAction || "error";
+      if (protoAction === "ignore" && constructorAction === "ignore") {
+        return obj;
+      }
+      if (protoAction !== "ignore" && constructorAction !== "ignore") {
+        if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
+          return obj;
+        }
+      } else if (protoAction !== "ignore" && constructorAction === "ignore") {
+        if (suspectProtoRx.test(text) === false) {
+          return obj;
+        }
+      } else {
+        if (suspectConstructorRx.test(text) === false) {
+          return obj;
+        }
+      }
+      return filter(obj, { protoAction, constructorAction, safe: options && options.safe });
+    }
+    function filter(obj, { protoAction = "error", constructorAction = "error", safe } = {}) {
+      let next = [obj];
+      while (next.length) {
+        const nodes = next;
+        next = [];
+        for (const node of nodes) {
+          if (protoAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "__proto__")) {
+            if (safe === true) {
+              return null;
+            } else if (protoAction === "error") {
+              throw new SyntaxError("Object contains forbidden prototype property");
+            }
+            delete node.__proto__;
+          }
+          if (constructorAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+            if (safe === true) {
+              return null;
+            } else if (constructorAction === "error") {
+              throw new SyntaxError("Object contains forbidden prototype property");
+            }
+            delete node.constructor;
+          }
+          for (const key in node) {
+            const value = node[key];
+            if (value && typeof value === "object") {
+              next.push(value);
+            }
+          }
+        }
+      }
+      return obj;
+    }
+    function parse(text, reviver, options) {
+      const stackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 0;
+      try {
+        return _parse(text, reviver, options);
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit;
+      }
+    }
+    function safeParse(text, reviver) {
+      const stackTraceLimit = Error.stackTraceLimit;
+      Error.stackTraceLimit = 0;
+      try {
+        return _parse(text, reviver, { safe: true });
+      } catch (_e) {
+        return null;
+      } finally {
+        Error.stackTraceLimit = stackTraceLimit;
+      }
+    }
+    module.exports = parse;
+    module.exports.default = parse;
+    module.exports.parse = parse;
+    module.exports.safeParse = safeParse;
+    module.exports.scan = filter;
+  }
+});
+
+// ../../node_modules/.pnpm/@ai-sdk+provider@1.1.3/node_modules/@ai-sdk/provider/dist/index.mjs
+var marker = "vercel.ai.error";
+var symbol = Symbol.for(marker);
+var _a;
+var _AISDKError = class _AISDKError2 extends Error {
+  /**
+   * Creates an AI SDK Error.
+   *
+   * @param {Object} params - The parameters for creating the error.
+   * @param {string} params.name - The name of the error.
+   * @param {string} params.message - The error message.
+   * @param {unknown} [params.cause] - The underlying cause of the error.
+   */
+  constructor({
+    name: name14,
+    message,
+    cause
+  }) {
+    super(message);
+    this[_a] = true;
+    this.name = name14;
+    this.cause = cause;
+  }
+  /**
+   * Checks if the given error is an AI SDK Error.
+   * @param {unknown} error - The error to check.
+   * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
+   */
+  static isInstance(error) {
+    return _AISDKError2.hasMarker(error, marker);
+  }
+  static hasMarker(error, marker15) {
+    const markerSymbol = Symbol.for(marker15);
+    return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
+  }
+};
+_a = symbol;
+var AISDKError = _AISDKError;
+function getErrorMessage(error) {
+  if (error == null) {
+    return "unknown error";
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return JSON.stringify(error);
+}
+var name3 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name3}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
+var InvalidArgumentError = class extends AISDKError {
+  constructor({
+    message,
+    cause,
+    argument
+  }) {
+    super({ name: name3, message, cause });
+    this[_a4] = true;
+    this.argument = argument;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker4);
+  }
+};
+_a4 = symbol4;
+var name6 = "AI_JSONParseError";
+var marker7 = `vercel.ai.error.${name6}`;
+var symbol7 = Symbol.for(marker7);
+var _a7;
+var JSONParseError = class extends AISDKError {
+  constructor({ text, cause }) {
+    super({
+      name: name6,
+      message: `JSON parsing failed: Text: ${text}.
+Error message: ${getErrorMessage(cause)}`,
+      cause
+    });
+    this[_a7] = true;
+    this.text = text;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker7);
+  }
+};
+_a7 = symbol7;
+var name12 = "AI_TypeValidationError";
+var marker13 = `vercel.ai.error.${name12}`;
+var symbol13 = Symbol.for(marker13);
+var _a13;
+var _TypeValidationError = class _TypeValidationError2 extends AISDKError {
+  constructor({ value, cause }) {
+    super({
+      name: name12,
+      message: `Type validation failed: Value: ${JSON.stringify(value)}.
+Error message: ${getErrorMessage(cause)}`,
+      cause
+    });
+    this[_a13] = true;
+    this.value = value;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker13);
+  }
+  /**
+   * Wraps an error into a TypeValidationError.
+   * If the cause is already a TypeValidationError with the same value, it returns the cause.
+   * Otherwise, it creates a new TypeValidationError.
+   *
+   * @param {Object} params - The parameters for wrapping the error.
+   * @param {unknown} params.value - The value that failed validation.
+   * @param {unknown} params.cause - The original error or cause of the validation failure.
+   * @returns {TypeValidationError} A TypeValidationError instance.
+   */
+  static wrap({
+    value,
+    cause
+  }) {
+    return _TypeValidationError2.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError2({ value, cause });
+  }
+};
+_a13 = symbol13;
+var TypeValidationError = _TypeValidationError;
+
+// ../../node_modules/.pnpm/nanoid@3.3.11/node_modules/nanoid/non-secure/index.js
+var customAlphabet = (alphabet, defaultSize = 21) => {
+  return (size = defaultSize) => {
+    let id = "";
+    let i = size | 0;
+    while (i--) {
+      id += alphabet[Math.random() * alphabet.length | 0];
+    }
+    return id;
+  };
+};
+
+// ../../node_modules/.pnpm/@ai-sdk+provider-utils@2.2.8_zod@3.25.76/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+var import_secure_json_parse = __toESM(require_secure_json_parse());
+var createIdGenerator = ({
+  prefix,
+  size: defaultSize = 16,
+  alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  separator = "-"
+} = {}) => {
+  const generator = customAlphabet(alphabet, defaultSize);
+  if (prefix == null) {
+    return generator;
+  }
+  if (alphabet.includes(separator)) {
+    throw new InvalidArgumentError({
+      argument: "separator",
+      message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
+    });
+  }
+  return (size) => `${prefix}${separator}${generator(size)}`;
+};
+createIdGenerator();
+var validatorSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.validator");
+function validator(validate) {
+  return { [validatorSymbol]: true, validate };
+}
+function isValidator(value) {
+  return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
+}
+function asValidator(value) {
+  return isValidator(value) ? value : zodValidator(value);
+}
+function zodValidator(zodSchema) {
+  return validator((value) => {
+    const result = zodSchema.safeParse(value);
+    return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+  });
+}
+function safeValidateTypes({
+  value,
+  schema
+}) {
+  const validator2 = asValidator(schema);
+  try {
+    if (validator2.validate == null) {
+      return { success: true, value };
+    }
+    const result = validator2.validate(value);
+    if (result.success) {
+      return result;
+    }
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: result.error })
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: error })
+    };
+  }
+}
+function safeParseJSON({
+  text,
+  schema
+}) {
+  try {
+    const value = import_secure_json_parse.default.parse(text);
+    if (schema == null) {
+      return { success: true, value, rawValue: value };
+    }
+    const validationResult = safeValidateTypes({ value, schema });
+    return validationResult.success ? { ...validationResult, rawValue: value } : validationResult;
+  } catch (error) {
+    return {
+      success: false,
+      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text, cause: error })
+    };
+  }
+}
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+function fixJson(input) {
+  const stack = ["ROOT"];
+  let lastValidIndex = -1;
+  let literalStart = null;
+  function processValueStart(char, i, swapState) {
+    {
+      switch (char) {
+        case '"': {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_STRING");
+          break;
+        }
+        case "f":
+        case "t":
+        case "n": {
+          lastValidIndex = i;
+          literalStart = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_LITERAL");
+          break;
+        }
+        case "-": {
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "0":
+        case "1":
+        case "2":
+        case "3":
+        case "4":
+        case "5":
+        case "6":
+        case "7":
+        case "8":
+        case "9": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "{": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_OBJECT_START");
+          break;
+        }
+        case "[": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_ARRAY_START");
+          break;
+        }
+      }
+    }
+  }
+  function processAfterObjectValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_OBJECT_AFTER_COMMA");
+        break;
+      }
+      case "}": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  function processAfterArrayValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_ARRAY_AFTER_COMMA");
+        break;
+      }
+      case "]": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    const currentState = stack[stack.length - 1];
+    switch (currentState) {
+      case "ROOT":
+        processValueStart(char, i, "FINISH");
+        break;
+      case "INSIDE_OBJECT_START": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+          case "}": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_COMMA": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_KEY": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_AFTER_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_KEY": {
+        switch (char) {
+          case ":": {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_BEFORE_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_BEFORE_VALUE": {
+        processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        processAfterObjectValue(char, i);
+        break;
+      }
+      case "INSIDE_STRING": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            lastValidIndex = i;
+            break;
+          }
+          case "\\": {
+            stack.push("INSIDE_STRING_ESCAPE");
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_START": {
+        switch (char) {
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        switch (char) {
+          case ",": {
+            stack.pop();
+            stack.push("INSIDE_ARRAY_AFTER_COMMA");
+            break;
+          }
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_COMMA": {
+        processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_STRING_ESCAPE": {
+        stack.pop();
+        lastValidIndex = i;
+        break;
+      }
+      case "INSIDE_NUMBER": {
+        switch (char) {
+          case "0":
+          case "1":
+          case "2":
+          case "3":
+          case "4":
+          case "5":
+          case "6":
+          case "7":
+          case "8":
+          case "9": {
+            lastValidIndex = i;
+            break;
+          }
+          case "e":
+          case "E":
+          case "-":
+          case ".": {
+            break;
+          }
+          case ",": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "}": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "]": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            break;
+          }
+          default: {
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, i + 1);
+        if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
+          stack.pop();
+          if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+            processAfterObjectValue(char, i);
+          } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+            processAfterArrayValue(char, i);
+          }
+        } else {
+          lastValidIndex = i;
+        }
+        break;
+      }
+    }
+  }
+  let result = input.slice(0, lastValidIndex + 1);
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const state = stack[i];
+    switch (state) {
+      case "INSIDE_STRING": {
+        result += '"';
+        break;
+      }
+      case "INSIDE_OBJECT_KEY":
+      case "INSIDE_OBJECT_AFTER_KEY":
+      case "INSIDE_OBJECT_AFTER_COMMA":
+      case "INSIDE_OBJECT_START":
+      case "INSIDE_OBJECT_BEFORE_VALUE":
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        result += "}";
+        break;
+      }
+      case "INSIDE_ARRAY_START":
+      case "INSIDE_ARRAY_AFTER_COMMA":
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        result += "]";
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, input.length);
+        if ("true".startsWith(partialLiteral)) {
+          result += "true".slice(partialLiteral.length);
+        } else if ("false".startsWith(partialLiteral)) {
+          result += "false".slice(partialLiteral.length);
+        } else if ("null".startsWith(partialLiteral)) {
+          result += "null".slice(partialLiteral.length);
+        }
+      }
+    }
+  }
+  return result;
+}
+function parsePartialJson(jsonText) {
+  if (jsonText === void 0) {
+    return { value: void 0, state: "undefined-input" };
+  }
+  let result = safeParseJSON({ text: jsonText });
+  if (result.success) {
+    return { value: result.value, state: "successful-parse" };
+  }
+  result = safeParseJSON({ text: fixJson(jsonText) });
+  if (result.success) {
+    return { value: result.value, state: "repaired-parse" };
+  }
+  return { value: void 0, state: "failed-parse" };
+}
+var textStreamPart2 = {
+  code: "0",
+  name: "text",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"text" parts expect a string value.');
+    }
+    return { type: "text", value };
+  }
+};
+var dataStreamPart = {
+  code: "2",
+  name: "data",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"data" parts expect an array value.');
+    }
+    return { type: "data", value };
+  }
+};
+var errorStreamPart2 = {
+  code: "3",
+  name: "error",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"error" parts expect a string value.');
+    }
+    return { type: "error", value };
+  }
+};
+var messageAnnotationsStreamPart = {
+  code: "8",
+  name: "message_annotations",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"message_annotations" parts expect an array value.');
+    }
+    return { type: "message_annotations", value };
+  }
+};
+var toolCallStreamPart = {
+  code: "9",
+  name: "tool_call",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string" || !("args" in value) || typeof value.args !== "object") {
+      throw new Error(
+        '"tool_call" parts expect an object with a "toolCallId", "toolName", and "args" property.'
+      );
+    }
+    return {
+      type: "tool_call",
+      value
+    };
+  }
+};
+var toolResultStreamPart = {
+  code: "a",
+  name: "tool_result",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("result" in value)) {
+      throw new Error(
+        '"tool_result" parts expect an object with a "toolCallId" and a "result" property.'
+      );
+    }
+    return {
+      type: "tool_result",
+      value
+    };
+  }
+};
+var toolCallStreamingStartStreamPart = {
+  code: "b",
+  name: "tool_call_streaming_start",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string") {
+      throw new Error(
+        '"tool_call_streaming_start" parts expect an object with a "toolCallId" and "toolName" property.'
+      );
+    }
+    return {
+      type: "tool_call_streaming_start",
+      value
+    };
+  }
+};
+var toolCallDeltaStreamPart = {
+  code: "c",
+  name: "tool_call_delta",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("argsTextDelta" in value) || typeof value.argsTextDelta !== "string") {
+      throw new Error(
+        '"tool_call_delta" parts expect an object with a "toolCallId" and "argsTextDelta" property.'
+      );
+    }
+    return {
+      type: "tool_call_delta",
+      value
+    };
+  }
+};
+var finishMessageStreamPart = {
+  code: "d",
+  name: "finish_message",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("finishReason" in value) || typeof value.finishReason !== "string") {
+      throw new Error(
+        '"finish_message" parts expect an object with a "finishReason" property.'
+      );
+    }
+    const result = {
+      finishReason: value.finishReason
+    };
+    if ("usage" in value && value.usage != null && typeof value.usage === "object" && "promptTokens" in value.usage && "completionTokens" in value.usage) {
+      result.usage = {
+        promptTokens: typeof value.usage.promptTokens === "number" ? value.usage.promptTokens : Number.NaN,
+        completionTokens: typeof value.usage.completionTokens === "number" ? value.usage.completionTokens : Number.NaN
+      };
+    }
+    return {
+      type: "finish_message",
+      value: result
+    };
+  }
+};
+var finishStepStreamPart = {
+  code: "e",
+  name: "finish_step",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("finishReason" in value) || typeof value.finishReason !== "string") {
+      throw new Error(
+        '"finish_step" parts expect an object with a "finishReason" property.'
+      );
+    }
+    const result = {
+      finishReason: value.finishReason,
+      isContinued: false
+    };
+    if ("usage" in value && value.usage != null && typeof value.usage === "object" && "promptTokens" in value.usage && "completionTokens" in value.usage) {
+      result.usage = {
+        promptTokens: typeof value.usage.promptTokens === "number" ? value.usage.promptTokens : Number.NaN,
+        completionTokens: typeof value.usage.completionTokens === "number" ? value.usage.completionTokens : Number.NaN
+      };
+    }
+    if ("isContinued" in value && typeof value.isContinued === "boolean") {
+      result.isContinued = value.isContinued;
+    }
+    return {
+      type: "finish_step",
+      value: result
+    };
+  }
+};
+var startStepStreamPart = {
+  code: "f",
+  name: "start_step",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("messageId" in value) || typeof value.messageId !== "string") {
+      throw new Error(
+        '"start_step" parts expect an object with an "id" property.'
+      );
+    }
+    return {
+      type: "start_step",
+      value: {
+        messageId: value.messageId
+      }
+    };
+  }
+};
+var reasoningStreamPart = {
+  code: "g",
+  name: "reasoning",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"reasoning" parts expect a string value.');
+    }
+    return { type: "reasoning", value };
+  }
+};
+var sourcePart = {
+  code: "h",
+  name: "source",
+  parse: (value) => {
+    if (value == null || typeof value !== "object") {
+      throw new Error('"source" parts expect a Source object.');
+    }
+    return {
+      type: "source",
+      value
+    };
+  }
+};
+var redactedReasoningStreamPart = {
+  code: "i",
+  name: "redacted_reasoning",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("data" in value) || typeof value.data !== "string") {
+      throw new Error(
+        '"redacted_reasoning" parts expect an object with a "data" property.'
+      );
+    }
+    return { type: "redacted_reasoning", value: { data: value.data } };
+  }
+};
+var reasoningSignatureStreamPart = {
+  code: "j",
+  name: "reasoning_signature",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("signature" in value) || typeof value.signature !== "string") {
+      throw new Error(
+        '"reasoning_signature" parts expect an object with a "signature" property.'
+      );
+    }
+    return {
+      type: "reasoning_signature",
+      value: { signature: value.signature }
+    };
+  }
+};
+var fileStreamPart = {
+  code: "k",
+  name: "file",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("data" in value) || typeof value.data !== "string" || !("mimeType" in value) || typeof value.mimeType !== "string") {
+      throw new Error(
+        '"file" parts expect an object with a "data" and "mimeType" property.'
+      );
+    }
+    return { type: "file", value };
+  }
+};
+var dataStreamParts = [
+  textStreamPart2,
+  dataStreamPart,
+  errorStreamPart2,
+  messageAnnotationsStreamPart,
+  toolCallStreamPart,
+  toolResultStreamPart,
+  toolCallStreamingStartStreamPart,
+  toolCallDeltaStreamPart,
+  finishMessageStreamPart,
+  finishStepStreamPart,
+  startStepStreamPart,
+  reasoningStreamPart,
+  sourcePart,
+  redactedReasoningStreamPart,
+  reasoningSignatureStreamPart,
+  fileStreamPart
+];
+var dataStreamPartsByCode = Object.fromEntries(
+  dataStreamParts.map((part) => [part.code, part])
+);
+Object.fromEntries(
+  dataStreamParts.map((part) => [part.name, part.code])
+);
+var validCodes2 = dataStreamParts.map((part) => part.code);
+var parseDataStreamPart = (line) => {
+  const firstSeparatorIndex = line.indexOf(":");
+  if (firstSeparatorIndex === -1) {
+    throw new Error("Failed to parse stream string. No separator found.");
+  }
+  const prefix = line.slice(0, firstSeparatorIndex);
+  if (!validCodes2.includes(prefix)) {
+    throw new Error(`Failed to parse stream string. Invalid code ${prefix}.`);
+  }
+  const code = prefix;
+  const textValue = line.slice(firstSeparatorIndex + 1);
+  const jsonValue = JSON.parse(textValue);
+  return dataStreamPartsByCode[code].parse(jsonValue);
+};
+var NEWLINE = "\n".charCodeAt(0);
+function concatChunks(chunks, totalLength) {
+  const concatenatedChunks = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    concatenatedChunks.set(chunk, offset);
+    offset += chunk.length;
+  }
+  chunks.length = 0;
+  return concatenatedChunks;
+}
+async function processDataStream({
+  stream,
+  onTextPart,
+  onReasoningPart,
+  onReasoningSignaturePart,
+  onRedactedReasoningPart,
+  onSourcePart,
+  onFilePart,
+  onDataPart,
+  onErrorPart,
+  onToolCallStreamingStartPart,
+  onToolCallDeltaPart,
+  onToolCallPart,
+  onToolResultPart,
+  onMessageAnnotationsPart,
+  onFinishMessagePart,
+  onFinishStepPart,
+  onStartStepPart
+}) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let totalLength = 0;
+  while (true) {
+    const { value } = await reader.read();
+    if (value) {
+      chunks.push(value);
+      totalLength += value.length;
+      if (value[value.length - 1] !== NEWLINE) {
+        continue;
+      }
+    }
+    if (chunks.length === 0) {
+      break;
+    }
+    const concatenatedChunks = concatChunks(chunks, totalLength);
+    totalLength = 0;
+    const streamParts = decoder.decode(concatenatedChunks, { stream: true }).split("\n").filter((line) => line !== "").map(parseDataStreamPart);
+    for (const { type, value: value2 } of streamParts) {
+      switch (type) {
+        case "text":
+          await (onTextPart == null ? void 0 : onTextPart(value2));
+          break;
+        case "reasoning":
+          await (onReasoningPart == null ? void 0 : onReasoningPart(value2));
+          break;
+        case "reasoning_signature":
+          await (onReasoningSignaturePart == null ? void 0 : onReasoningSignaturePart(value2));
+          break;
+        case "redacted_reasoning":
+          await (onRedactedReasoningPart == null ? void 0 : onRedactedReasoningPart(value2));
+          break;
+        case "file":
+          await (onFilePart == null ? void 0 : onFilePart(value2));
+          break;
+        case "source":
+          await (onSourcePart == null ? void 0 : onSourcePart(value2));
+          break;
+        case "data":
+          await (onDataPart == null ? void 0 : onDataPart(value2));
+          break;
+        case "error":
+          await (onErrorPart == null ? void 0 : onErrorPart(value2));
+          break;
+        case "message_annotations":
+          await (onMessageAnnotationsPart == null ? void 0 : onMessageAnnotationsPart(value2));
+          break;
+        case "tool_call_streaming_start":
+          await (onToolCallStreamingStartPart == null ? void 0 : onToolCallStreamingStartPart(value2));
+          break;
+        case "tool_call_delta":
+          await (onToolCallDeltaPart == null ? void 0 : onToolCallDeltaPart(value2));
+          break;
+        case "tool_call":
+          await (onToolCallPart == null ? void 0 : onToolCallPart(value2));
+          break;
+        case "tool_result":
+          await (onToolResultPart == null ? void 0 : onToolResultPart(value2));
+          break;
+        case "finish_message":
+          await (onFinishMessagePart == null ? void 0 : onFinishMessagePart(value2));
+          break;
+        case "finish_step":
+          await (onFinishStepPart == null ? void 0 : onFinishStepPart(value2));
+          break;
+        case "start_step":
+          await (onStartStepPart == null ? void 0 : onStartStepPart(value2));
+          break;
+        default: {
+          const exhaustiveCheck = type;
+          throw new Error(`Unknown stream part type: ${exhaustiveCheck}`);
+        }
+      }
+    }
+  }
+}
+function isComplexValue(value) {
+  if (value === null || value === void 0) return false;
+  if (value instanceof Date) return false;
+  return typeof value === "object";
+}
+function serializeQueryValue(value) {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (isComplexValue(value)) {
+    return JSON.stringify(value, (_key, val) => {
+      if (val instanceof Date) {
+        return val.toISOString();
+      }
+      return val;
+    });
+  }
+  return String(value);
+}
+function toQueryParams(params, flattenKeys = []) {
+  const searchParams = new URLSearchParams();
+  const keysToFlatten = flattenKeys;
+  function addParams(obj) {
+    for (const [key, value] of Object.entries(obj)) {
+      if (value === void 0 || value === null) continue;
+      if (keysToFlatten.includes(key) && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
+        addParams(value);
+      } else {
+        searchParams.set(key, serializeQueryValue(value));
+      }
+    }
+  }
+  addParams(params);
+  return searchParams.toString();
+}
 function parseClientRequestContext(requestContext$1) {
   if (requestContext$1) {
     if (requestContext$1 instanceof requestContext.RequestContext) {
@@ -34,7 +1124,7 @@ function requestContextQueryString(requestContext, delimiter = "?") {
 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";
 }
-function zodToJsonSchema(zodSchema) {
+function zodToJsonSchema2(zodSchema) {
   if (!isZodType(zodSchema)) {
     return zodSchema;
   }
@@ -53,7 +1143,7 @@ function processClientTools(clientTools) {
           key,
           {
             ...value,
-            parameters: value.parameters ? zodToJsonSchema(value.parameters) : void 0
+            parameters: value.parameters ? zodToJsonSchema2(value.parameters) : void 0
           }
         ];
       } else {
@@ -61,8 +1151,8 @@ function processClientTools(clientTools) {
           key,
           {
             ...value,
-            inputSchema: value.inputSchema ? zodToJsonSchema(value.inputSchema) : void 0,
-            outputSchema: value.outputSchema ? zodToJsonSchema(value.outputSchema) : void 0
+            inputSchema: value.inputSchema ? zodToJsonSchema2(value.inputSchema) : void 0,
+            outputSchema: value.outputSchema ? zodToJsonSchema2(value.outputSchema) : void 0
           }
         ];
       }
@@ -241,10 +1331,7 @@ async function executeToolCallAndRespond({
             ]
           }
         ];
-        return respondFn({
-          ...params,
-          messages: updatedMessages
-        });
+        return respondFn(updatedMessages, params);
       }
     }
   }
@@ -332,8 +1419,8 @@ var Agent = class extends BaseResource {
   async generateLegacy(params) {
     const processedParams = {
       ...params,
-      output: params.output ? zodToJsonSchema(params.output) : void 0,
-      experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : void 0,
+      output: params.output ? zodToJsonSchema2(params.output) : void 0,
+      experimental_output: params.experimental_output ? zodToJsonSchema2(params.experimental_output) : void 0,
       requestContext: parseClientRequestContext(params.requestContext),
       clientTools: processClientTools(params.clientTools)
     };
@@ -388,26 +1475,24 @@ var Agent = class extends BaseResource {
     }
     return response;
   }
-  async generate(messagesOrParams, options) {
-    let params;
-    if (typeof messagesOrParams === "object" && "messages" in messagesOrParams) {
-      params = messagesOrParams;
-    } else {
-      params = {
-        messages: messagesOrParams,
-        ...options
-      };
-    }
+  async generate(messages, options) {
+    const params = {
+      ...options,
+      messages
+    };
     const processedParams = {
       ...params,
       requestContext: parseClientRequestContext(params.requestContext),
       clientTools: processClientTools(params.clientTools),
       structuredOutput: params.structuredOutput ? {
         ...params.structuredOutput,
-        schema: zodToJsonSchema(params.structuredOutput.schema)
+        schema: zodToJsonSchema2(params.structuredOutput.schema)
       } : void 0
     };
-    const { resourceId, threadId, requestContext } = processedParams;
+    const { memory, requestContext } = processedParams;
+    const { resource, thread } = memory ?? {};
+    const resourceId = resource;
+    const threadId = typeof thread === "string" ? thread : thread?.id;
     const response = await this.request(
       `/api/agents/${this.agentId}/generate`,
       {
@@ -494,7 +1579,7 @@ var Agent = class extends BaseResource {
         replaceLastMessage
       });
     }
-    await uiUtils.processDataStream({
+    await processDataStream({
       stream,
       onTextPart(value) {
         if (currentTextPart == null) {
@@ -591,7 +1676,7 @@ var Agent = class extends BaseResource {
       onToolCallDeltaPart(value) {
         const partialToolCall = partialToolCalls[value.toolCallId];
         partialToolCall.text += value.argsTextDelta;
-        const { value: partialArgs } = uiUtils.parsePartialJson(partialToolCall.text);
+        const { value: partialArgs } = parsePartialJson(partialToolCall.text);
         const invocation = {
           state: "partial-call",
           step: partialToolCall.step,
@@ -697,8 +1782,8 @@ var Agent = class extends BaseResource {
   async streamLegacy(params) {
     const processedParams = {
       ...params,
-      output: params.output ? zodToJsonSchema(params.output) : void 0,
-      experimental_output: params.experimental_output ? zodToJsonSchema(params.experimental_output) : void 0,
+      output: params.output ? zodToJsonSchema2(params.output) : void 0,
+      experimental_output: params.experimental_output ? zodToJsonSchema2(params.experimental_output) : void 0,
       requestContext: parseClientRequestContext(params.requestContext),
       clientTools: processClientTools(params.clientTools)
     };
@@ -710,7 +1795,7 @@ var Agent = class extends BaseResource {
       headers: response.headers
     });
     streamResponse.processDataStream = async (options = {}) => {
-      await uiUtils.processDataStream({
+      await processDataStream({
         stream: streamResponse.body,
         ...options
       });
@@ -793,7 +1878,7 @@ var Agent = class extends BaseResource {
           case "tripwire": {
             message.parts.push({
               type: "text",
-              text: chunk.payload.tripwireReason
+              text: chunk.payload.reason
             });
             execUpdate();
             break;
@@ -916,7 +2001,7 @@ var Agent = class extends BaseResource {
           case "tool-call-delta": {
             const partialToolCall = partialToolCalls[chunk.payload.toolCallId];
             partialToolCall.text += chunk.payload.argsTextDelta;
-            const { value: partialArgs } = uiUtils.parsePartialJson(partialToolCall.text);
+            const { value: partialArgs } = parsePartialJson(partialToolCall.text);
             const invocation = {
               state: "partial-call",
               step: partialToolCall.step,
@@ -1108,8 +2193,35 @@ var Agent = class extends BaseResource {
     }
     return response;
   }
-  async network(params) {
+  async network(messages, params) {
     const response = await this.request(`/api/agents/${this.agentId}/network`, {
+      method: "POST",
+      body: {
+        messages,
+        ...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 approveNetworkToolCall(params) {
+    const response = await this.request(`/api/agents/${this.agentId}/approve-network-tool-call`, {
       method: "POST",
       body: params,
       stream: true
@@ -1132,23 +2244,42 @@ var Agent = class extends BaseResource {
     };
     return streamResponse;
   }
-  async stream(messagesOrParams, options) {
-    let params;
-    if (typeof messagesOrParams === "object" && "messages" in messagesOrParams) {
-      params = messagesOrParams;
-    } else {
-      params = {
-        messages: messagesOrParams,
-        ...options
-      };
+  async declineNetworkToolCall(params) {
+    const response = await this.request(`/api/agents/${this.agentId}/decline-network-tool-call`, {
+      method: "POST",
+      body: params,
+      stream: true
+    });
+    if (!response.body) {
+      throw new Error("No response body");
     }
+    const streamResponse = new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+    streamResponse.processDataStream = async ({
+      onChunk
+    }) => {
+      await processMastraNetworkStream({
+        stream: streamResponse.body,
+        onChunk
+      });
+    };
+    return streamResponse;
+  }
+  async stream(messagesOrParams, options) {
+    let params = {
+      messages: messagesOrParams,
+      ...options
+    };
     const processedParams = {
       ...params,
       requestContext: parseClientRequestContext(params.requestContext),
       clientTools: processClientTools(params.clientTools),
       structuredOutput: params.structuredOutput ? {
         ...params.structuredOutput,
-        schema: zodToJsonSchema(params.structuredOutput.schema)
+        schema: zodToJsonSchema2(params.structuredOutput.schema)
       } : void 0
     };
     let readableController;
@@ -1219,6 +2350,26 @@ var Agent = class extends BaseResource {
     };
     return streamResponse;
   }
+  /**
+   * Approves a pending tool call and returns the complete response (non-streaming).
+   * Used when `requireToolApproval` is enabled with generate() to allow the agent to proceed.
+   */
+  async approveToolCallGenerate(params) {
+    return this.request(`/api/agents/${this.agentId}/approve-tool-call-generate`, {
+      method: "POST",
+      body: params
+    });
+  }
+  /**
+   * Declines a pending tool call and returns the complete response (non-streaming).
+   * Used when `requireToolApproval` is enabled with generate() to prevent tool execution.
+   */
+  async declineToolCallGenerate(params) {
+    return this.request(`/api/agents/${this.agentId}/decline-tool-call-generate`, {
+      method: "POST",
+      body: params
+    });
+  }
   /**
    * Processes the stream response and handles tool calls
    */
@@ -1371,7 +2522,8 @@ var Agent = class extends BaseResource {
    */
   resetModel() {
     return this.request(`/api/agents/${this.agentId}/model/reset`, {
-      method: "POST"
+      method: "POST",
+      body: {}
     });
   }
   /**
@@ -1405,15 +2557,21 @@ var MemoryThread = class extends BaseResource {
     this.threadId = threadId;
     this.agentId = agentId;
   }
+  /**
+   * Builds the query string for agentId (if provided)
+   */
+  getAgentIdQueryParam(prefix = "?") {
+    return this.agentId ? `${prefix}agentId=${this.agentId}` : "";
+  }
   /**
    * Retrieves the memory thread details
    * @param requestContext - Optional request context to pass as query parameter
    * @returns Promise containing thread details including title and metadata
    */
   get(requestContext) {
-    return this.request(
-      `/api/memory/threads/${this.threadId}?agentId=${this.agentId}${requestContextQueryString(requestContext, "&")}`
-    );
+    const agentIdParam = this.getAgentIdQueryParam("?");
+    const contextParam = requestContextQueryString(requestContext, agentIdParam ? "&" : "?");
+    return this.request(`/api/memory/threads/${this.threadId}${agentIdParam}${contextParam}`);
   }
   /**
    * Updates the memory thread properties
@@ -1421,13 +2579,12 @@ var MemoryThread = class extends BaseResource {
    * @returns Promise containing updated thread details
    */
   update(params) {
-    return this.request(
-      `/api/memory/threads/${this.threadId}?agentId=${this.agentId}${requestContextQueryString(params.requestContext, "&")}`,
-      {
-        method: "PATCH",
-        body: params
-      }
-    );
+    const agentIdParam = this.getAgentIdQueryParam("?");
+    const contextParam = requestContextQueryString(params.requestContext, agentIdParam ? "&" : "?");
+    return this.request(`/api/memory/threads/${this.threadId}${agentIdParam}${contextParam}`, {
+      method: "PATCH",
+      body: params
+    });
   }
   /**
    * Deletes the memory thread
@@ -1435,12 +2592,11 @@ var MemoryThread = class extends BaseResource {
    * @returns Promise containing deletion result
    */
   delete(requestContext) {
-    return this.request(
-      `/api/memory/threads/${this.threadId}?agentId=${this.agentId}${requestContextQueryString(requestContext, "&")}`,
-      {
-        method: "DELETE"
-      }
-    );
+    const agentIdParam = this.getAgentIdQueryParam("?");
+    const contextParam = requestContextQueryString(requestContext, agentIdParam ? "&" : "?");
+    return this.request(`/api/memory/threads/${this.threadId}${agentIdParam}${contextParam}`, {
+      method: "DELETE"
+    });
   }
   /**
    * Retrieves paginated messages associated with the thread with filtering and ordering options
@@ -1450,6 +2606,7 @@ var MemoryThread = class extends BaseResource {
   listMessages(params = {}) {
     const { page, perPage, orderBy, filter, include, resourceId, requestContext } = params;
     const queryParams = {};
+    if (this.agentId) queryParams.agentId = this.agentId;
     if (resourceId) queryParams.resourceId = resourceId;
     if (page !== void 0) queryParams.page = String(page);
     if (perPage !== void 0) queryParams.perPage = String(perPage);
@@ -1458,7 +2615,7 @@ var MemoryThread = class extends BaseResource {
     if (include) queryParams.include = JSON.stringify(include);
     const query = new URLSearchParams(queryParams);
     const queryString = query.toString();
-    const url = `/api/memory/threads/${this.threadId}/messages?agentId=${this.agentId}${queryString ? `&${queryString}` : ""}${requestContextQueryString(requestContext, "&")}`;
+    const url = `/api/memory/threads/${this.threadId}/messages${queryString ? `?${queryString}` : ""}${requestContextQueryString(requestContext, queryString ? "&" : "?")}`;
     return this.request(url);
   }
   /**
@@ -1469,17 +2626,32 @@ var MemoryThread = class extends BaseResource {
    * @returns Promise containing deletion result
    */
   deleteMessages(messageIds, requestContext) {
-    const query = new URLSearchParams({
-      agentId: this.agentId
-    });
+    const queryParams = {};
+    if (this.agentId) queryParams.agentId = this.agentId;
+    const query = new URLSearchParams(queryParams);
+    const queryString = query.toString();
     return this.request(
-      `/api/memory/messages/delete?${query.toString()}${requestContextQueryString(requestContext, "&")}`,
+      `/api/memory/messages/delete${queryString ? `?${queryString}` : ""}${requestContextQueryString(requestContext, queryString ? "&" : "?")}`,
       {
         method: "POST",
         body: { messageIds }
       }
     );
   }
+  /**
+   * Clones the thread with all its messages to a new thread
+   * @param params - Clone parameters including optional new thread ID, title, metadata, and message filters
+   * @returns Promise containing the cloned thread and copied messages
+   */
+  clone(params = {}) {
+    const { requestContext, ...body } = params;
+    const agentIdParam = this.getAgentIdQueryParam("?");
+    const contextParam = requestContextQueryString(requestContext, agentIdParam ? "&" : "?");
+    return this.request(`/api/memory/threads/${this.threadId}/clone${agentIdParam}${contextParam}`, {
+      method: "POST",
+      body
+    });
+  }
 };
 
 // src/resources/vector.ts
@@ -1587,460 +2759,303 @@ var Tool = class extends BaseResource {
   }
 };
 
-// src/resources/workflow.ts
-var RECORD_SEPARATOR = "";
-var Workflow = class extends BaseResource {
-  constructor(options, workflowId) {
+// src/resources/processor.ts
+var Processor = class extends BaseResource {
+  constructor(options, processorId) {
     super(options);
-    this.workflowId = workflowId;
+    this.processorId = processorId;
   }
   /**
-   * Retrieves details about the workflow
+   * Retrieves details about the processor
    * @param requestContext - Optional request context to pass as query parameter
-   * @returns Promise containing workflow details including steps and graphs
+   * @returns Promise containing processor details including phases and configurations
    */
   details(requestContext) {
-    return this.request(`/api/workflows/${this.workflowId}${requestContextQueryString(requestContext)}`);
+    return this.request(`/api/processors/${this.processorId}${requestContextQueryString(requestContext)}`);
   }
   /**
-   * Retrieves all runs for a workflow
-   * @param params - Parameters for filtering runs
-   * @param requestContext - Optional request context to pass as query parameter
-   * @returns Promise containing workflow runs array
+   * Executes the processor with the provided parameters
+   * @param params - Parameters required for processor execution including phase and messages
+   * @returns Promise containing the processor execution results
    */
-  runs(params, requestContext) {
-    const requestContextParam = base64RequestContext(parseClientRequestContext(requestContext));
-    const searchParams = new URLSearchParams();
-    if (params?.fromDate) {
-      searchParams.set("fromDate", params.fromDate.toISOString());
-    }
-    if (params?.toDate) {
-      searchParams.set("toDate", params.toDate.toISOString());
-    }
-    if (params?.page !== void 0) {
-      searchParams.set("page", String(params.page));
-    }
-    if (params?.perPage !== void 0) {
-      searchParams.set("perPage", String(params.perPage));
-    }
-    if (params?.limit !== null && params?.limit !== void 0) {
-      if (params.limit === false) {
-        searchParams.set("limit", "false");
-      } else if (typeof params.limit === "number" && params.limit > 0 && Number.isInteger(params.limit)) {
-        searchParams.set("limit", String(params.limit));
-      }
-    }
-    if (params?.offset !== null && params?.offset !== void 0 && !isNaN(Number(params?.offset))) {
-      searchParams.set("offset", String(params.offset));
-    }
-    if (params?.resourceId) {
-      searchParams.set("resourceId", params.resourceId);
-    }
-    if (requestContextParam) {
-      searchParams.set("requestContext", requestContextParam);
-    }
-    if (searchParams.size) {
-      return this.request(`/api/workflows/${this.workflowId}/runs?${searchParams}`);
-    } else {
-      return this.request(`/api/workflows/${this.workflowId}/runs`);
-    }
+  execute(params) {
+    const body = {
+      phase: params.phase,
+      messages: params.messages,
+      agentId: params.agentId,
+      requestContext: parseClientRequestContext(params.requestContext)
+    };
+    return this.request(`/api/processors/${this.processorId}/execute`, {
+      method: "POST",
+      body
+    });
   }
-  /**
-   * Retrieves a specific workflow run by its ID
-   * @param runId - The ID of the workflow run to retrieve
-   * @param requestContext - Optional request context to pass as query parameter
-   * @returns Promise containing the workflow run details
-   */
-  runById(runId, requestContext) {
-    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}${requestContextQueryString(requestContext)}`);
+};
+function deserializeWorkflowError(result) {
+  if (result.status === "failed" && result.error) {
+    result.error = error.getErrorFromUnknown(result.error, {
+      fallbackMessage: "Unknown workflow error",
+      supportSerialization: false
+    });
+  }
+  return result;
+}
+var RECORD_SEPARATOR = "";
+var Run = class extends BaseResource {
+  constructor(options, workflowId, runId) {
+    super(options);
+    this.workflowId = workflowId;
+    this.runId = runId;
   }
   /**
-   * 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 requestContext - Optional request context to pass as query parameter
-   * @returns Promise containing the workflow run execution result
+   * Creates a transform stream that parses RECORD_SEPARATOR-delimited JSON chunks
    */
-  runExecutionResult(runId, requestContext) {
-    return this.request(
-      `/api/workflows/${this.workflowId}/runs/${runId}/execution-result${requestContextQueryString(requestContext)}`
-    );
+  createChunkTransformStream() {
+    let failedChunk = void 0;
+    return 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 {
+        }
+      }
+    });
   }
   /**
    * Cancels a specific workflow run by its ID
-   * @param runId - The ID of the workflow run to cancel
    * @returns Promise containing a success message
+   * @deprecated Use `cancel()` instead
    */
-  cancelRun(runId) {
-    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}/cancel`, {
+  cancelRun() {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${this.runId}/cancel`, {
       method: "POST"
     });
   }
   /**
-   * Creates a new workflow run
-   * @param params - Optional object containing the optional runId
-   * @returns Promise containing the runId of the created run with methods to control execution
+   * Cancels a workflow run.
+   *
+   * This method aborts any running steps and updates the workflow status to 'canceled' .
+   * It works for both actively running workflows and suspended/waiting workflows.
+   *
+   * ## How cancellation works
+   *
+   * When called, the workflow will:
+   * 1. **Trigger the abort signal** - Uses the standard Web API AbortSignal to notify running steps
+   * 2. **Prevent subsequent steps** - No further steps will be executed
+   *
+   * ## Abort signal behavior
+   *
+   * Steps that check the `abortSignal` parameter can respond to cancellation:
+   * - Steps can listen to the 'abort' event: `abortSignal.addEventListener('abort', callback)`
+   * - Steps can check if already aborted: `if (abortSignal.aborted) { ... }`
+   * - Useful for canceling timeouts, network requests, or long-running operations
+   *
+   * **Note:** Steps must actively check the abort signal to be canceled mid-execution.
+   * Steps that don't check the signal will run to completion, but subsequent steps won't execute.
+   *
+   * @returns Promise that resolves with `{ message: 'Workflow run canceled' }` when cancellation succeeds
+   * @throws {HTTPException} 400 - If workflow ID or run ID is missing
+   * @throws {HTTPException} 404 - If workflow or workflow run is not found
+   *
+   * @example
+   * ```typescript
+   * const run = await workflow.createRun({ runId: 'run-123' });
+   * await run.cancel();
+   * // Returns: { message: 'Workflow run canceled' }
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Example of a step that responds to cancellation
+   * const step = createStep({
+   *   id: 'long-running-step',
+   *   execute: async ({ inputData, abortSignal, abort }) => {
+   *     const timeout = new Promise((resolve) => {
+   *       const timer = setTimeout(() => resolve('done'), 10000);
+   *
+   *       // Clean up if canceled
+   *       abortSignal.addEventListener('abort', () => {
+   *         clearTimeout(timer);
+   *         resolve('canceled');
+   *       });
+   *     });
+   *
+   *     const result = await timeout;
+   *
+   *     // Check if aborted after async operation
+   *     if (abortSignal.aborted) {
+   *       return abort(); // Stop execution
+   *     }
+   *
+   *     return { result };
+   *   }
+   * });
+   * ```
    */
-  async createRun(params) {
-    const searchParams = new URLSearchParams();
-    if (!!params?.runId) {
-      searchParams.set("runId", params.runId);
-    }
-    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,
-          initialState: p.initialState,
-          requestContext: p.requestContext,
-          tracingOptions: p.tracingOptions
-        });
-      },
-      startAsync: async (p) => {
-        return this.startAsync({
-          runId,
-          inputData: p.inputData,
-          initialState: p.initialState,
-          requestContext: p.requestContext,
-          tracingOptions: p.tracingOptions
-        });
-      },
-      stream: async (p) => {
-        return this.stream({
-          runId,
-          inputData: p.inputData,
-          initialState: p.initialState,
-          requestContext: p.requestContext
-        });
-      },
-      resume: async (p) => {
-        return this.resume({
-          runId,
-          step: p.step,
-          resumeData: p.resumeData,
-          requestContext: p.requestContext,
-          tracingOptions: p.tracingOptions
-        });
-      },
-      resumeAsync: async (p) => {
-        return this.resumeAsync({
-          runId,
-          step: p.step,
-          resumeData: p.resumeData,
-          requestContext: p.requestContext,
-          tracingOptions: p.tracingOptions
-        });
-      },
-      resumeStreamVNext: async (p) => {
-        return this.resumeStreamVNext({
-          runId,
-          step: p.step,
-          resumeData: p.resumeData,
-          requestContext: p.requestContext
-        });
-      }
-    };
+  cancel() {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${this.runId}/cancel`, {
+      method: "POST"
+    });
   }
   /**
    * Starts a workflow run synchronously without waiting for the workflow to complete
-   * @param params - Object containing the runId, inputData, initialState and requestContext
+   * @param params - Object containing the inputData, initialState and requestContext
    * @returns Promise containing success message
    */
   start(params) {
     const requestContext = parseClientRequestContext(params.requestContext);
-    return this.request(`/api/workflows/${this.workflowId}/start?runId=${params.runId}`, {
+    return this.request(`/api/workflows/${this.workflowId}/start?runId=${this.runId}`, {
       method: "POST",
       body: {
         inputData: params?.inputData,
         initialState: params?.initialState,
         requestContext,
-        tracingOptions: params.tracingOptions
+        tracingOptions: params.tracingOptions,
+        perStep: params.perStep
       }
     });
   }
   /**
    * Resumes a suspended workflow step synchronously without waiting for the workflow to complete
-   * @param params - Object containing the runId, step, resumeData and requestContext
+   * @param params - Object containing the step, resumeData and requestContext
    * @returns Promise containing success message
    */
   resume({
     step,
-    runId,
     resumeData,
     tracingOptions,
+    perStep,
     ...rest
   }) {
     const requestContext = parseClientRequestContext(rest.requestContext);
-    return this.request(`/api/workflows/${this.workflowId}/resume?runId=${runId}`, {
-      method: "POST",
-      body: {
-        step,
-        resumeData,
-        requestContext,
-        tracingOptions
-      }
-    });
-  }
-  /**
-   * Starts a workflow run asynchronously and returns a promise that resolves when the workflow is complete
-   * @param params - Object containing the optional runId, inputData, initialState and requestContext
-   * @returns Promise containing the workflow execution results
-   */
-  startAsync(params) {
-    const searchParams = new URLSearchParams();
-    if (!!params?.runId) {
-      searchParams.set("runId", params.runId);
-    }
-    const requestContext = parseClientRequestContext(params.requestContext);
-    return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
+    return this.request(`/api/workflows/${this.workflowId}/resume?runId=${this.runId}`, {
       method: "POST",
       body: {
-        inputData: params.inputData,
-        initialState: params.initialState,
-        requestContext,
-        tracingOptions: params.tracingOptions
-      }
-    });
-  }
-  /**
-   * Starts a workflow run and returns a stream
-   * @param params - Object containing the optional runId, inputData, initialState and requestContext
-   * @returns Promise containing the workflow execution results
-   */
-  async stream(params) {
-    const searchParams = new URLSearchParams();
-    if (!!params?.runId) {
-      searchParams.set("runId", params.runId);
-    }
-    const requestContext = parseClientRequestContext(params.requestContext);
-    const response = await this.request(
-      `/api/workflows/${this.workflowId}/stream?${searchParams.toString()}`,
-      {
-        method: "POST",
-        body: {
-          inputData: params.inputData,
-          initialState: params.initialState,
-          requestContext,
-          tracingOptions: params.tracingOptions
-        },
-        stream: true
-      }
-    );
-    if (!response.ok) {
-      throw new Error(`Failed to stream workflow: ${response.statusText}`);
-    }
-    if (!response.body) {
-      throw new Error("Response body is null");
-    }
-    let failedChunk = void 0;
-    const transformStream = new TransformStream({
-      start() {
-      },
-      async transform(chunk, controller) {
-        try {
-          const decoded = new TextDecoder().decode(chunk);
-          const chunks = decoded.split(RECORD_SEPARATOR);
-          for (const chunk2 of chunks) {
-            if (chunk2) {
-              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
-              try {
-                const parsedChunk = JSON.parse(newChunk);
-                controller.enqueue(parsedChunk);
-                failedChunk = void 0;
-              } catch {
-                failedChunk = newChunk;
-              }
-            }
-          }
-        } catch {
-        }
-      }
-    });
-    return response.body.pipeThrough(transformStream);
-  }
-  /**
-   * Observes workflow stream for a workflow run
-   * @param params - Object containing the runId
-   * @returns Promise containing the workflow execution results
-   */
-  async observeStream(params) {
-    const searchParams = new URLSearchParams();
-    searchParams.set("runId", params.runId);
-    const response = await this.request(
-      `/api/workflows/${this.workflowId}/observe-stream?${searchParams.toString()}`,
-      {
-        method: "POST",
-        stream: true
-      }
-    );
-    if (!response.ok) {
-      throw new Error(`Failed to observe workflow stream: ${response.statusText}`);
-    }
-    if (!response.body) {
-      throw new Error("Response body is null");
-    }
-    let failedChunk = void 0;
-    const transformStream = new TransformStream({
-      start() {
-      },
-      async transform(chunk, controller) {
-        try {
-          const decoded = new TextDecoder().decode(chunk);
-          const chunks = decoded.split(RECORD_SEPARATOR);
-          for (const chunk2 of chunks) {
-            if (chunk2) {
-              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
-              try {
-                const parsedChunk = JSON.parse(newChunk);
-                controller.enqueue(parsedChunk);
-                failedChunk = void 0;
-              } catch {
-                failedChunk = newChunk;
-              }
-            }
-          }
-        } catch {
-        }
+        step,
+        resumeData,
+        requestContext,
+        tracingOptions,
+        perStep
       }
     });
-    return response.body.pipeThrough(transformStream);
+  }
+  /**
+   * Starts a workflow run asynchronously and returns a promise that resolves when the workflow is complete
+   * @param params - Object containing the inputData, initialState and requestContext
+   * @returns Promise containing the workflow execution results
+   */
+  startAsync(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("runId", this.runId);
+    const requestContext = parseClientRequestContext(params.requestContext);
+    return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
+      method: "POST",
+      body: {
+        inputData: params.inputData,
+        initialState: params.initialState,
+        requestContext,
+        tracingOptions: params.tracingOptions,
+        resourceId: params.resourceId,
+        perStep: params.perStep
+      }
+    }).then(deserializeWorkflowError);
   }
   /**
    * Starts a workflow run and returns a stream
-   * @param params - Object containing the optional runId, inputData, initialState and requestContext
+   * @param params - Object containing the inputData, initialState and requestContext
    * @returns Promise containing the workflow execution results
    */
-  async streamVNext(params) {
+  async stream(params) {
     const searchParams = new URLSearchParams();
-    if (!!params?.runId) {
-      searchParams.set("runId", params.runId);
-    }
+    searchParams.set("runId", this.runId);
     const requestContext = parseClientRequestContext(params.requestContext);
     const response = await this.request(
-      `/api/workflows/${this.workflowId}/streamVNext?${searchParams.toString()}`,
+      `/api/workflows/${this.workflowId}/stream?${searchParams.toString()}`,
       {
         method: "POST",
         body: {
           inputData: params.inputData,
           initialState: params.initialState,
           requestContext,
-          closeOnSuspend: params.closeOnSuspend,
-          tracingOptions: params.tracingOptions
+          tracingOptions: params.tracingOptions,
+          resourceId: params.resourceId,
+          perStep: params.perStep,
+          closeOnSuspend: params.closeOnSuspend
         },
         stream: true
       }
     );
     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_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);
+    return response.body.pipeThrough(this.createChunkTransformStream());
   }
   /**
-   * Observes workflow vNext stream for a workflow run
-   * @param params - Object containing the runId
+   * Observes workflow stream for a workflow run
    * @returns Promise containing the workflow execution results
    */
-  async observeStreamVNext(params) {
+  async observeStream() {
     const searchParams = new URLSearchParams();
-    searchParams.set("runId", params.runId);
+    searchParams.set("runId", this.runId);
     const response = await this.request(
-      `/api/workflows/${this.workflowId}/observe-streamVNext?${searchParams.toString()}`,
+      `/api/workflows/${this.workflowId}/observe-stream?${searchParams.toString()}`,
       {
         method: "POST",
         stream: true
       }
     );
     if (!response.ok) {
-      throw new Error(`Failed to observe stream vNext workflow: ${response.statusText}`);
+      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);
+    return response.body.pipeThrough(this.createChunkTransformStream());
   }
   /**
    * Resumes a suspended workflow step asynchronously and returns a promise that resolves when the workflow is complete
-   * @param params - Object containing the runId, step, resumeData and requestContext
+   * @param params - Object containing the step, resumeData and requestContext
    * @returns Promise containing the workflow resume results
    */
   resumeAsync(params) {
     const requestContext = parseClientRequestContext(params.requestContext);
-    return this.request(`/api/workflows/${this.workflowId}/resume-async?runId=${params.runId}`, {
+    return this.request(`/api/workflows/${this.workflowId}/resume-async?runId=${this.runId}`, {
       method: "POST",
       body: {
         step: params.step,
         resumeData: params.resumeData,
         requestContext,
-        tracingOptions: params.tracingOptions
+        tracingOptions: params.tracingOptions,
+        perStep: params.perStep
       }
-    });
+    }).then(deserializeWorkflowError);
   }
   /**
-   * 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 requestContext
+   * Resumes a suspended workflow step that uses stream asynchronously and returns a promise that resolves when the workflow is complete
+   * @param params - Object containing the step, resumeData and requestContext
    * @returns Promise containing the workflow resume results
    */
-  async resumeStreamVNext(params) {
+  async resumeStream(params) {
     const searchParams = new URLSearchParams();
-    searchParams.set("runId", params.runId);
+    searchParams.set("runId", this.runId);
     const requestContext = parseClientRequestContext(params.requestContext);
     const response = await this.request(
       `/api/workflows/${this.workflowId}/resume-stream?${searchParams.toString()}`,
@@ -2050,7 +3065,8 @@ var Workflow = class extends BaseResource {
           step: params.step,
           resumeData: params.resumeData,
           requestContext,
-          tracingOptions: params.tracingOptions
+          tracingOptions: params.tracingOptions,
+          perStep: params.perStep
         },
         stream: true
       }
@@ -2061,31 +3077,213 @@ var Workflow = class extends BaseResource {
     if (!response.body) {
       throw new Error("Response body is null");
     }
-    let failedChunk = void 0;
-    const transformStream = new TransformStream({
-      start() {
-      },
-      async transform(chunk, controller) {
-        try {
-          const decoded = new TextDecoder().decode(chunk);
-          const chunks = decoded.split(RECORD_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(this.createChunkTransformStream());
+  }
+  /**
+   * Restarts an active workflow run synchronously without waiting for the workflow to complete
+   * @param params - Object containing the requestContext
+   * @returns Promise containing success message
+   */
+  restart(params) {
+    const requestContext = parseClientRequestContext(params.requestContext);
+    return this.request(`/api/workflows/${this.workflowId}/restart?runId=${this.runId}`, {
+      method: "POST",
+      body: {
+        requestContext,
+        tracingOptions: params.tracingOptions
+      }
+    });
+  }
+  /**
+   * Restarts an active workflow run asynchronously
+   * @param params - optional object containing the requestContext
+   * @returns Promise containing the workflow restart results
+   */
+  restartAsync(params) {
+    const requestContext = parseClientRequestContext(params?.requestContext);
+    return this.request(`/api/workflows/${this.workflowId}/restart-async?runId=${this.runId}`, {
+      method: "POST",
+      body: {
+        requestContext,
+        tracingOptions: params?.tracingOptions
+      }
+    }).then(deserializeWorkflowError);
+  }
+  /**
+   * Time travels a workflow run synchronously without waiting for the workflow to complete
+   * @param params - Object containing the step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
+   * @returns Promise containing success message
+   */
+  timeTravel({ requestContext: paramsRequestContext, ...params }) {
+    const requestContext = parseClientRequestContext(paramsRequestContext);
+    return this.request(`/api/workflows/${this.workflowId}/time-travel?runId=${this.runId}`, {
+      method: "POST",
+      body: {
+        ...params,
+        requestContext
+      }
+    });
+  }
+  /**
+   * Time travels a workflow run asynchronously
+   * @param params - Object containing the step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
+   * @returns Promise containing the workflow time travel results
+   */
+  timeTravelAsync({ requestContext: paramsRequestContext, ...params }) {
+    const requestContext = parseClientRequestContext(paramsRequestContext);
+    return this.request(`/api/workflows/${this.workflowId}/time-travel-async?runId=${this.runId}`, {
+      method: "POST",
+      body: {
+        ...params,
+        requestContext
+      }
+    }).then(deserializeWorkflowError);
+  }
+  /**
+   * Time travels a workflow run and returns a stream
+   * @param params - Object containing the step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
+   * @returns Promise containing the workflow execution results
+   */
+  async timeTravelStream({ requestContext: paramsRequestContext, ...params }) {
+    const requestContext = parseClientRequestContext(paramsRequestContext);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/time-travel-stream?runId=${this.runId}`,
+      {
+        method: "POST",
+        body: {
+          ...params,
+          requestContext
+        },
+        stream: true
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to time travel workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    return response.body.pipeThrough(this.createChunkTransformStream());
+  }
+};
+
+// src/resources/workflow.ts
+var RECORD_SEPARATOR2 = "";
+var Workflow = class extends BaseResource {
+  constructor(options, workflowId) {
+    super(options);
+    this.workflowId = workflowId;
+  }
+  /**
+   * Retrieves details about the workflow
+   * @param requestContext - Optional request context to pass as query parameter
+   * @returns Promise containing workflow details including steps and graphs
+   */
+  details(requestContext) {
+    return this.request(`/api/workflows/${this.workflowId}${requestContextQueryString(requestContext)}`);
+  }
+  /**
+   * Retrieves all runs for a workflow
+   * @param params - Parameters for filtering runs
+   * @param requestContext - Optional request context to pass as query parameter
+   * @returns Promise containing workflow runs array
+   */
+  runs(params, requestContext) {
+    const requestContextParam = base64RequestContext(parseClientRequestContext(requestContext));
+    const searchParams = new URLSearchParams();
+    if (params?.fromDate) {
+      searchParams.set("fromDate", params.fromDate.toISOString());
+    }
+    if (params?.toDate) {
+      searchParams.set("toDate", params.toDate.toISOString());
+    }
+    if (params?.page !== void 0) {
+      searchParams.set("page", String(params.page));
+    }
+    if (params?.perPage !== void 0) {
+      searchParams.set("perPage", String(params.perPage));
+    }
+    if (params?.limit !== null && params?.limit !== void 0) {
+      if (params.limit === false) {
+        searchParams.set("limit", "false");
+      } else if (typeof params.limit === "number" && params.limit > 0 && Number.isInteger(params.limit)) {
+        searchParams.set("limit", String(params.limit));
+      }
+    }
+    if (params?.offset !== null && params?.offset !== void 0 && !isNaN(Number(params?.offset))) {
+      searchParams.set("offset", String(params.offset));
+    }
+    if (params?.resourceId) {
+      searchParams.set("resourceId", params.resourceId);
+    }
+    if (params?.status) {
+      searchParams.set("status", params.status);
+    }
+    if (requestContextParam) {
+      searchParams.set("requestContext", requestContextParam);
+    }
+    if (searchParams.size) {
+      return this.request(`/api/workflows/${this.workflowId}/runs?${searchParams}`);
+    } else {
+      return this.request(`/api/workflows/${this.workflowId}/runs`);
+    }
+  }
+  /**
+   * Retrieves a specific workflow run by its ID
+   * @param runId - The ID of the workflow run to retrieve
+   * @param options - Optional configuration
+   * @param options.requestContext - Optional request context to pass as query parameter
+   * @param options.fields - Optional array of fields to return (e.g., ['result', 'steps']). Available fields: result, error, payload, steps, activeStepsPath, serializedStepGraph. Metadata fields (runId, workflowName, resourceId, createdAt, updatedAt) and status are always included.
+   * @param options.withNestedWorkflows - Whether to include nested workflow data in steps. Defaults to true. Set to false for better performance when you don't need nested workflow details.
+   * @returns Promise containing the workflow run details with metadata and processed execution state
+   */
+  runById(runId, options) {
+    const searchParams = new URLSearchParams();
+    if (options?.fields && options.fields.length > 0) {
+      searchParams.set("fields", options.fields.join(","));
+    }
+    if (options?.withNestedWorkflows !== void 0) {
+      searchParams.set("withNestedWorkflows", String(options.withNestedWorkflows));
+    }
+    const requestContextParam = base64RequestContext(parseClientRequestContext(options?.requestContext));
+    if (requestContextParam) {
+      searchParams.set("requestContext", requestContextParam);
+    }
+    const queryString = searchParams.size > 0 ? `?${searchParams.toString()}` : "";
+    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}${queryString}`);
+  }
+  /**
+   * Deletes a specific workflow run by its ID
+   * @param runId - The ID of the workflow run to delete
+   * @returns Promise containing a success message
+   */
+  deleteRunById(runId) {
+    return this.request(`/api/workflows/${this.workflowId}/runs/${runId}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Creates a new workflow run
+   * @param params - Optional object containing the optional runId
+   * @returns Promise containing the Run instance
+   */
+  async createRun(params) {
+    const searchParams = new URLSearchParams();
+    if (!!params?.runId) {
+      searchParams.set("runId", params.runId);
+    }
+    const res = await this.request(
+      `/api/workflows/${this.workflowId}/create-run?${searchParams.toString()}`,
+      {
+        method: "POST",
+        body: {
+          resourceId: params?.resourceId,
+          disableScorers: params?.disableScorers
         }
       }
-    });
-    return response.body.pipeThrough(transformStream);
+    );
+    const run = new Run(this.options, this.workflowId, res.runId);
+    return run;
   }
   /**
    * Creates a new ReadableStream from an iterable or async iterable of objects,
@@ -2100,7 +3298,7 @@ var Workflow = class extends BaseResource {
       async start(controller) {
         try {
           for await (const record of records) {
-            const json = JSON.stringify(record) + RECORD_SEPARATOR;
+            const json = JSON.stringify(record) + RECORD_SEPARATOR2;
             controller.enqueue(encoder.encode(json));
           }
           controller.close();
@@ -2110,142 +3308,6 @@ var Workflow = class extends BaseResource {
       }
     });
   }
-  /**
-   * Restarts an active workflow run synchronously without waiting for the workflow to complete
-   * @param params - Object containing the runId and requestContext
-   * @returns Promise containing success message
-   */
-  restart(params) {
-    const requestContext = parseClientRequestContext(params.requestContext);
-    return this.request(`/api/workflows/${this.workflowId}/restart?runId=${params.runId}`, {
-      method: "POST",
-      body: {
-        requestContext,
-        tracingOptions: params.tracingOptions
-      }
-    });
-  }
-  /**
-   * Restarts an active workflow run asynchronously
-   * @param params - Object containing the runId and requestContext
-   * @returns Promise containing the workflow restart results
-   */
-  restartAsync(params) {
-    const requestContext = parseClientRequestContext(params.requestContext);
-    return this.request(`/api/workflows/${this.workflowId}/restart-async?runId=${params.runId}`, {
-      method: "POST",
-      body: {
-        requestContext,
-        tracingOptions: params.tracingOptions
-      }
-    });
-  }
-  /**
-   * Restart all active workflow runs synchronously without waiting for the workflow to complete
-   * @returns Promise containing success message
-   */
-  restartAllActiveWorkflowRuns() {
-    return this.request(`/api/workflows/${this.workflowId}/restart-all-active-workflow-runs`, {
-      method: "POST"
-    });
-  }
-  /**
-   * Restart all active workflow runs asynchronously
-   * @returns Promise containing success message
-   */
-  restartAllActiveWorkflowRunsAsync() {
-    return this.request(`/api/workflows/${this.workflowId}/restart-all-active-workflow-runs-async`, {
-      method: "POST"
-    });
-  }
-  /**
-   * Time travels a workflow run synchronously without waiting for the workflow to complete
-   * @param params - Object containing the runId, step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
-   * @returns Promise containing success message
-   */
-  timeTravel({
-    runId,
-    requestContext: paramsRequestContext,
-    ...params
-  }) {
-    const requestContext = parseClientRequestContext(paramsRequestContext);
-    return this.request(`/api/workflows/${this.workflowId}/time-travel?runId=${runId}`, {
-      method: "POST",
-      body: {
-        ...params,
-        requestContext
-      }
-    });
-  }
-  /**
-   * Time travels a workflow run asynchronously
-   * @param params - Object containing the runId, step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
-   * @returns Promise containing the workflow time travel results
-   */
-  timeTravelAsync({
-    runId,
-    requestContext: paramsRequestContext,
-    ...params
-  }) {
-    const requestContext = parseClientRequestContext(paramsRequestContext);
-    return this.request(`/api/workflows/${this.workflowId}/time-travel-async?runId=${runId}`, {
-      method: "POST",
-      body: {
-        ...params,
-        requestContext
-      }
-    });
-  }
-  /**
-   * Time travels a workflow run and returns a stream
-   * @param params - Object containing the runId, step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
-   * @returns Promise containing the workflow execution results
-   */
-  async timeTravelStream({ runId, requestContext: paramsRequestContext, ...params }) {
-    const requestContext = parseClientRequestContext(paramsRequestContext);
-    const response = await this.request(
-      `/api/workflows/${this.workflowId}/time-travel-stream?runId=${runId}`,
-      {
-        method: "POST",
-        body: {
-          ...params,
-          requestContext
-        },
-        stream: true
-      }
-    );
-    if (!response.ok) {
-      throw new Error(`Failed to time travel 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);
-  }
 };
 
 // src/resources/a2a.ts
@@ -2360,7 +3422,7 @@ var MCPTool = class extends BaseResource {
 };
 
 // src/resources/agent-builder.ts
-var RECORD_SEPARATOR2 = "";
+var RECORD_SEPARATOR3 = "";
 var AgentBuilder = class extends BaseResource {
   constructor(options, actionId) {
     super(options);
@@ -2406,7 +3468,7 @@ var AgentBuilder = 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_SEPARATOR3);
           for (const chunk2 of chunks) {
             if (chunk2) {
               const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
@@ -2520,7 +3582,7 @@ var AgentBuilder = 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_SEPARATOR3);
           buffer = chunks.pop() || "";
           for (const chunk of chunks) {
             if (chunk) {
@@ -2572,36 +3634,11 @@ var AgentBuilder = class extends BaseResource {
     }
     return response.body.pipeThrough(this.createRecordParserTransform());
   }
-  /**
-   * Streams agent builder action progress in real-time using VNext streaming.
-   * This calls `/api/agent-builder/:actionId/streamVNext`.
-   */
-  async streamVNext(params, runId) {
-    const searchParams = new URLSearchParams();
-    if (runId) {
-      searchParams.set("runId", runId);
-    }
-    const requestContext = parseClientRequestContext(params.requestContext);
-    const { requestContext: _, ...actionParams } = params;
-    const url = `/api/agent-builder/${this.actionId}/streamVNext${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
-    const response = await this.request(url, {
-      method: "POST",
-      body: { ...actionParams, requestContext },
-      stream: true
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to stream agent builder action VNext: ${response.statusText}`);
-    }
-    if (!response.body) {
-      throw new Error("Response body is null");
-    }
-    return response.body.pipeThrough(this.createRecordParserTransform());
-  }
   /**
    * Observes an existing agent builder action run stream.
    * Replays cached execution from the beginning, then continues with live stream.
    * This is the recommended method for recovery after page refresh/hot reload.
-   * This calls `/api/agent-builder/:actionId/observe` (which delegates to observeStreamVNext).
+   * This calls `/api/agent-builder/:actionId/observe`
    */
   async observeStream(params) {
     const searchParams = new URLSearchParams();
@@ -2619,27 +3656,6 @@ var AgentBuilder = class extends BaseResource {
     }
     return response.body.pipeThrough(this.createRecordParserTransform());
   }
-  /**
-   * Observes an existing agent builder action run stream using VNext streaming API.
-   * Replays cached execution from the beginning, then continues with live stream.
-   * This calls `/api/agent-builder/:actionId/observe-streamVNext`.
-   */
-  async observeStreamVNext(params) {
-    const searchParams = new URLSearchParams();
-    searchParams.set("runId", params.runId);
-    const url = `/api/agent-builder/${this.actionId}/observe-streamVNext?${searchParams.toString()}`;
-    const response = await this.request(url, {
-      method: "POST",
-      stream: true
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to observe agent builder action stream VNext: ${response.statusText}`);
-    }
-    if (!response.body) {
-      throw new Error("Response body is null");
-    }
-    return response.body.pipeThrough(this.createRecordParserTransform());
-  }
   /**
    * Observes an existing agent builder action run stream using legacy streaming API.
    * Replays cached execution from the beginning, then continues with live stream.
@@ -2687,9 +3703,22 @@ var AgentBuilder = class extends BaseResource {
   /**
    * Gets a specific action run by its ID.
    * This calls `/api/agent-builder/:actionId/runs/:runId`.
+   * @param runId - The ID of the action run to retrieve
+   * @param options - Optional configuration
+   * @param options.fields - Optional array of fields to return (e.g., ['result', 'steps']). Available fields: result, error, payload, steps, activeStepsPath, serializedStepGraph. Metadata fields (runId, workflowName, resourceId, createdAt, updatedAt) and status are always included.
+   * @param options.withNestedWorkflows - Whether to include nested workflow data in steps. Defaults to true. Set to false for better performance when you don't need nested workflow details.
+   * @returns Promise containing the action run details with metadata and processed execution state
    */
-  async runById(runId) {
-    const url = `/api/agent-builder/${this.actionId}/runs/${runId}`;
+  async runById(runId, options) {
+    const searchParams = new URLSearchParams();
+    if (options?.fields && options.fields.length > 0) {
+      searchParams.set("fields", options.fields.join(","));
+    }
+    if (options?.withNestedWorkflows !== void 0) {
+      searchParams.set("withNestedWorkflows", String(options.withNestedWorkflows));
+    }
+    const queryString = searchParams.size > 0 ? `?${searchParams.toString()}` : "";
+    const url = `/api/agent-builder/${this.actionId}/runs/${runId}${queryString}`;
     return this.request(url, {
       method: "GET"
     });
@@ -2738,16 +3767,6 @@ var AgentBuilder = class extends BaseResource {
       method: "GET"
     });
   }
-  /**
-   * Gets the execution result of an agent builder action run.
-   * This calls `/api/agent-builder/:actionId/runs/:runId/execution-result`.
-   */
-  async runExecutionResult(runId) {
-    const url = `/api/agent-builder/${this.actionId}/runs/${runId}/execution-result`;
-    return this.request(url, {
-      method: "GET"
-    });
-  }
   /**
    * Cancels an agent builder action run.
    * This calls `/api/agent-builder/:actionId/runs/:runId/cancel`.
@@ -2774,14 +3793,17 @@ var Observability = class extends BaseResource {
     return this.request(`/api/observability/traces/${traceId}`);
   }
   /**
-   * Retrieves paginated list of traces with optional filtering
-   * @param params - Parameters for pagination and filtering
+   * Retrieves paginated list of traces with optional filtering.
+   * This is the legacy API preserved for backward compatibility.
+   *
+   * @param params - Parameters for pagination and filtering (legacy format)
    * @returns Promise containing paginated traces and pagination info
+   * @deprecated Use {@link listTraces} instead for new features like ordering and more filters.
    */
   getTraces(params) {
     const { pagination, filters } = params;
     const { page, perPage, dateRange } = pagination || {};
-    const { name, spanType, entityId, entityType } = filters || {};
+    const { name: name14, spanType, entityId, entityType } = filters || {};
     const searchParams = new URLSearchParams();
     if (page !== void 0) {
       searchParams.set("page", String(page));
@@ -2789,8 +3811,8 @@ var Observability = class extends BaseResource {
     if (perPage !== void 0) {
       searchParams.set("perPage", String(perPage));
     }
-    if (name) {
-      searchParams.set("name", name);
+    if (name14) {
+      searchParams.set("name", name14);
     }
     if (spanType !== void 0) {
       searchParams.set("spanType", String(spanType));
@@ -2809,25 +3831,34 @@ var Observability = class extends BaseResource {
     const queryString = searchParams.toString();
     return this.request(`/api/observability/traces${queryString ? `?${queryString}` : ""}`);
   }
+  /**
+   * Retrieves paginated list of traces with optional filtering and sorting.
+   * This is the new API with improved filtering options.
+   *
+   * @param params - Parameters for pagination, filtering, and ordering
+   * @returns Promise containing paginated traces and pagination info
+   */
+  listTraces(params = {}) {
+    const queryString = toQueryParams(params, ["filters", "pagination", "orderBy"]);
+    return this.request(`/api/observability/traces${queryString ? `?${queryString}` : ""}`);
+  }
   /**
    * Retrieves scores by trace ID and span ID
    * @param params - Parameters containing trace ID, span ID, and pagination options
    * @returns Promise containing scores and pagination info
    */
   listScoresBySpan(params) {
-    const { traceId, spanId, page, perPage } = params;
-    const searchParams = new URLSearchParams();
-    if (page !== void 0) {
-      searchParams.set("page", String(page));
-    }
-    if (perPage !== void 0) {
-      searchParams.set("perPage", String(perPage));
-    }
-    const queryString = searchParams.toString();
+    const { traceId, spanId, ...pagination } = params;
+    const queryString = toQueryParams(pagination);
     return this.request(
       `/api/observability/traces/${encodeURIComponent(traceId)}/${encodeURIComponent(spanId)}/scores${queryString ? `?${queryString}` : ""}`
     );
   }
+  /**
+   * Scores one or more traces using a specified scorer.
+   * @param params - Scorer name and targets to score
+   * @returns Promise containing the scoring status
+   */
   score(params) {
     return this.request(`/api/observability/traces/score`, {
       method: "POST",
@@ -2836,6 +3867,41 @@ var Observability = class extends BaseResource {
   }
 };
 
+// src/resources/stored-agent.ts
+var StoredAgent = class extends BaseResource {
+  constructor(options, storedAgentId) {
+    super(options);
+    this.storedAgentId = storedAgentId;
+  }
+  /**
+   * Retrieves details about the stored agent
+   * @returns Promise containing stored agent details
+   */
+  details() {
+    return this.request(`/api/stored/agents/${encodeURIComponent(this.storedAgentId)}`);
+  }
+  /**
+   * Updates the stored agent with the provided fields
+   * @param params - Fields to update
+   * @returns Promise containing the updated stored agent
+   */
+  update(params) {
+    return this.request(`/api/stored/agents/${encodeURIComponent(this.storedAgentId)}`, {
+      method: "PATCH",
+      body: params
+    });
+  }
+  /**
+   * Deletes the stored agent
+   * @returns Promise containing deletion confirmation
+   */
+  delete() {
+    return this.request(`/api/stored/agents/${encodeURIComponent(this.storedAgentId)}`, {
+      method: "DELETE"
+    });
+  }
+};
+
 // src/client.ts
 var MastraClient = class extends BaseResource {
   observability;
@@ -2872,22 +3938,26 @@ var MastraClient = class extends BaseResource {
     return new Agent(this.options, agentId);
   }
   /**
-   * Lists memory threads for a resource with pagination support
-   * @param params - Parameters containing resource ID, pagination options, and optional request context
+   * Lists memory threads with optional filtering by resourceId and/or metadata
+   * @param params - Parameters containing optional filters, pagination options, and request context
    * @returns Promise containing paginated array of memory threads with metadata
    */
-  async listMemoryThreads(params) {
-    const queryParams = new URLSearchParams({
-      resourceId: params.resourceId,
-      resourceid: params.resourceId,
-      agentId: params.agentId,
-      ...params.page !== void 0 && { page: params.page.toString() },
-      ...params.perPage !== void 0 && { perPage: params.perPage.toString() },
-      ...params.orderBy && { orderBy: params.orderBy },
-      ...params.sortDirection && { sortDirection: params.sortDirection }
-    });
+  async listMemoryThreads(params = {}) {
+    const queryParams = new URLSearchParams();
+    if (params.resourceId) {
+      queryParams.set("resourceId", params.resourceId);
+    }
+    if (params.metadata) {
+      queryParams.set("metadata", JSON.stringify(params.metadata));
+    }
+    if (params.agentId) queryParams.set("agentId", params.agentId);
+    if (params.page !== void 0) queryParams.set("page", params.page.toString());
+    if (params.perPage !== void 0) queryParams.set("perPage", params.perPage.toString());
+    if (params.orderBy) queryParams.set("orderBy", params.orderBy);
+    if (params.sortDirection) queryParams.set("sortDirection", params.sortDirection);
+    const queryString = queryParams.toString();
     const response = await this.request(
-      `/api/memory/threads?${queryParams.toString()}${requestContextQueryString(params.requestContext, "&")}`
+      `/api/memory/threads${queryString ? `?${queryString}` : ""}${requestContextQueryString(params.requestContext, queryString ? "&" : "?")}`
     );
     const actualResponse = "threads" in response ? response : {
       threads: response,
@@ -2922,20 +3992,29 @@ var MastraClient = class extends BaseResource {
   /**
    * Gets a memory thread instance by ID
    * @param threadId - ID of the memory thread to retrieve
+   * @param agentId - Optional agent ID. When not provided, uses storage directly
    * @returns MemoryThread instance
    */
   getMemoryThread({ threadId, agentId }) {
     return new MemoryThread(this.options, threadId, agentId);
   }
+  /**
+   * Lists messages for a thread.
+   * @param threadId - ID of the thread
+   * @param opts - Optional parameters including agentId, networkId, and requestContext
+   *   - When agentId is provided, uses the agent's memory
+   *   - When networkId is provided, uses the network endpoint
+   *   - When neither is provided, uses storage directly
+   * @returns Promise containing the thread messages
+   */
   listThreadMessages(threadId, opts = {}) {
-    if (!opts.agentId && !opts.networkId) {
-      throw new Error("Either agentId or networkId must be provided");
-    }
     let url = "";
-    if (opts.agentId) {
-      url = `/api/memory/threads/${threadId}/messages?agentId=${opts.agentId}${requestContextQueryString(opts.requestContext, "&")}`;
-    } else if (opts.networkId) {
+    if (opts.networkId) {
       url = `/api/memory/network/threads/${threadId}/messages?networkId=${opts.networkId}${requestContextQueryString(opts.requestContext, "&")}`;
+    } else if (opts.agentId) {
+      url = `/api/memory/threads/${threadId}/messages?agentId=${opts.agentId}${requestContextQueryString(opts.requestContext, "&")}`;
+    } else {
+      url = `/api/memory/threads/${threadId}/messages${requestContextQueryString(opts.requestContext, "?")}`;
     }
     return this.request(url);
   }
@@ -2993,6 +4072,28 @@ var MastraClient = class extends BaseResource {
   getTool(toolId) {
     return new Tool(this.options, toolId);
   }
+  /**
+   * Retrieves all available processors
+   * @param requestContext - Optional request context to pass as query parameter
+   * @returns Promise containing map of processor IDs to processor details
+   */
+  listProcessors(requestContext) {
+    const requestContextParam = base64RequestContext(parseClientRequestContext(requestContext));
+    const searchParams = new URLSearchParams();
+    if (requestContextParam) {
+      searchParams.set("requestContext", requestContextParam);
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/processors${queryString ? `?${queryString}` : ""}`);
+  }
+  /**
+   * Gets a processor instance by ID
+   * @param processorId - ID of the processor to retrieve
+   * @returns Processor instance
+   */
+  getProcessor(processorId) {
+    return new Processor(this.options, processorId);
+  }
   /**
    * Retrieves all available workflows
    * @param requestContext - Optional request context to pass as query parameter
@@ -3342,15 +4443,89 @@ var MastraClient = class extends BaseResource {
   getTrace(traceId) {
     return this.observability.getTrace(traceId);
   }
+  /**
+   * Retrieves paginated list of traces with optional filtering.
+   * This is the legacy API preserved for backward compatibility.
+   *
+   * @param params - Parameters for pagination and filtering (legacy format)
+   * @returns Promise containing paginated traces and pagination info
+   * @deprecated Use {@link listTraces} instead for new features like ordering and more filters.
+   */
   getTraces(params) {
     return this.observability.getTraces(params);
   }
+  /**
+   * Retrieves paginated list of traces with optional filtering and sorting.
+   * This is the new API with improved filtering options.
+   *
+   * @param params - Parameters for pagination, filtering, and ordering
+   * @returns Promise containing paginated traces and pagination info
+   */
+  listTraces(params = {}) {
+    return this.observability.listTraces(params);
+  }
   listScoresBySpan(params) {
     return this.observability.listScoresBySpan(params);
   }
   score(params) {
     return this.observability.score(params);
   }
+  // ============================================================================
+  // Stored Agents
+  // ============================================================================
+  /**
+   * Lists all stored agents with optional pagination
+   * @param params - Optional pagination and ordering parameters
+   * @returns Promise containing paginated list of stored agents
+   */
+  listStoredAgents(params) {
+    const searchParams = new URLSearchParams();
+    if (params?.page !== void 0) {
+      searchParams.set("page", String(params.page));
+    }
+    if (params?.perPage !== void 0) {
+      searchParams.set("perPage", String(params.perPage));
+    }
+    if (params?.orderBy) {
+      if (params.orderBy.field) {
+        searchParams.set("orderBy[field]", params.orderBy.field);
+      }
+      if (params.orderBy.direction) {
+        searchParams.set("orderBy[direction]", params.orderBy.direction);
+      }
+    }
+    const queryString = searchParams.toString();
+    return this.request(`/api/stored/agents${queryString ? `?${queryString}` : ""}`);
+  }
+  /**
+   * Creates a new stored agent
+   * @param params - Agent configuration including id, name, instructions, model, etc.
+   * @returns Promise containing the created stored agent
+   */
+  createStoredAgent(params) {
+    return this.request("/api/stored/agents", {
+      method: "POST",
+      body: params
+    });
+  }
+  /**
+   * Gets a stored agent instance by ID for further operations (details, update, delete)
+   * @param storedAgentId - ID of the stored agent to retrieve
+   * @returns StoredAgent instance
+   */
+  getStoredAgent(storedAgentId) {
+    return new StoredAgent(this.options, storedAgentId);
+  }
+  // ============================================================================
+  // System
+  // ============================================================================
+  /**
+   * Retrieves installed Mastra packages and their versions
+   * @returns Promise containing the list of installed Mastra packages
+   */
+  getSystemPackages() {
+    return this.request("/api/system/packages");
+  }
 };
 
 // src/tools.ts