@mastra/client-js 1.0.0-beta.11 → 1.0.0-beta.14

package/dist/index.js

@@ -1,11 +1,1066 @@
-import { processDataStream, parsePartialJson } from '@ai-sdk/ui-utils';
 import { v4 } from '@lukeed/uuid';
 import { getErrorFromUnknown } from '@mastra/core/error';
 import { RequestContext } from '@mastra/core/request-context';
 import { isVercelTool } from '@mastra/core/tools/is-vercel-tool';
-import { zodToJsonSchema as zodToJsonSchema$1 } from '@mastra/schema-compat/zod-to-json';
+import { zodToJsonSchema } from '@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 = 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 parseClientRequestContext(requestContext) {
   if (requestContext) {
     if (requestContext instanceof RequestContext) {
@@ -32,11 +1087,11 @@ 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;
   }
-  return zodToJsonSchema$1(zodSchema);
+  return zodToJsonSchema(zodSchema);
 }
 
 // src/utils/process-client-tools.ts
@@ -51,7 +1106,7 @@ function processClientTools(clientTools) {
           key,
           {
             ...value,
-            parameters: value.parameters ? zodToJsonSchema(value.parameters) : void 0
+            parameters: value.parameters ? zodToJsonSchema2(value.parameters) : void 0
           }
         ];
       } else {
@@ -59,8 +1114,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
           }
         ];
       }
@@ -330,8 +1385,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)
     };
@@ -402,7 +1457,7 @@ var Agent = class extends BaseResource {
       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;
@@ -695,8 +1750,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)
     };
@@ -1146,7 +2201,7 @@ var Agent = class extends BaseResource {
       clientTools: processClientTools(params.clientTools),
       structuredOutput: params.structuredOutput ? {
         ...params.structuredOutput,
-        schema: zodToJsonSchema(params.structuredOutput.schema)
+        schema: zodToJsonSchema2(params.structuredOutput.schema)
       } : void 0
     };
     let readableController;
@@ -1584,186 +2639,68 @@ var Tool = class extends BaseResource {
     });
   }
 };
-
-// src/resources/workflow.ts
+function deserializeWorkflowError(result) {
+  if (result.status === "failed" && result.error) {
+    result.error = getErrorFromUnknown(result.error, {
+      fallbackMessage: "Unknown workflow error",
+      supportSerialization: false
+    });
+  }
+  return result;
+}
 var RECORD_SEPARATOR = "";
-var Workflow = class extends BaseResource {
-  constructor(options, workflowId) {
+var Run = class extends BaseResource {
+  constructor(options, workflowId, runId) {
     super(options);
     this.workflowId = workflowId;
+    this.runId = runId;
   }
   /**
-   * 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
+   * Creates a transform stream that parses RECORD_SEPARATOR-delimited JSON chunks
    */
-  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));
+  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 {
+        }
       }
-    }
-    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`);
-    }
-  }
-  /**
-   * 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)}`);
-  }
-  /**
-   * 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"
     });
   }
-  /**
-   * 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
-   */
-  runExecutionResult(runId, requestContext) {
-    return this.request(
-      `/api/workflows/${this.workflowId}/runs/${runId}/execution-result${requestContextQueryString(requestContext)}`
-    );
-  }
   /**
    * Cancels a specific workflow run by its ID
-   * @param runId - The ID of the workflow run to cancel
    * @returns Promise containing a success message
    */
-  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
-   */
-  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
-        });
-      }
-    };
-  }
   /**
    * 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,
@@ -1775,18 +2712,17 @@ var Workflow = class extends BaseResource {
   }
   /**
    * 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,
     ...rest
   }) {
     const requestContext = parseClientRequestContext(rest.requestContext);
-    return this.request(`/api/workflows/${this.workflowId}/resume?runId=${runId}`, {
+    return this.request(`/api/workflows/${this.workflowId}/resume?runId=${this.runId}`, {
       method: "POST",
       body: {
         step,
@@ -1798,14 +2734,12 @@ var Workflow = class extends BaseResource {
   }
   /**
    * 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
+   * @param params - Object containing the 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);
-    }
+    searchParams.set("runId", this.runId);
     const requestContext = parseClientRequestContext(params.requestContext);
     return this.request(`/api/workflows/${this.workflowId}/start-async?${searchParams.toString()}`, {
       method: "POST",
@@ -1813,20 +2747,19 @@ var Workflow = class extends BaseResource {
         inputData: params.inputData,
         initialState: params.initialState,
         requestContext,
-        tracingOptions: params.tracingOptions
+        tracingOptions: params.tracingOptions,
+        resourceId: params.resourceId
       }
-    });
+    }).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 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}/stream?${searchParams.toString()}`,
@@ -1836,7 +2769,8 @@ var Workflow = class extends BaseResource {
           inputData: params.inputData,
           initialState: params.initialState,
           requestContext,
-          tracingOptions: params.tracingOptions
+          tracingOptions: params.tracingOptions,
+          resourceId: params.resourceId
         },
         stream: true
       }
@@ -1847,40 +2781,15 @@ 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(transformStream);
+    return response.body.pipeThrough(this.createChunkTransformStream());
   }
   /**
    * Observes workflow stream for a workflow run
-   * @param params - Object containing the runId
    * @returns Promise containing the workflow execution results
    */
-  async observeStream(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-stream?${searchParams.toString()}`,
       {
@@ -1894,97 +2803,47 @@ 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(transformStream);
+    return response.body.pipeThrough(this.createChunkTransformStream());
   }
   /**
    * 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) {
     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}/streamVNext?${searchParams.toString()}`,
-      {
-        method: "POST",
-        body: {
-          inputData: params.inputData,
-          initialState: params.initialState,
-          requestContext,
-          closeOnSuspend: params.closeOnSuspend,
-          tracingOptions: params.tracingOptions
-        },
-        stream: true
-      }
-    );
-    if (!response.ok) {
-      throw new Error(`Failed to stream vNext workflow: ${response.statusText}`);
-    }
-    if (!response.body) {
-      throw new Error("Response body is null");
-    }
-    let failedChunk = void 0;
-    const transformStream = new TransformStream({
-      start() {
-      },
-      async transform(chunk, controller) {
-        try {
-          const decoded = new TextDecoder().decode(chunk);
-          const chunks = decoded.split(RECORD_SEPARATOR);
-          for (const chunk2 of chunks) {
-            if (chunk2) {
-              const newChunk = failedChunk ? failedChunk + chunk2 : chunk2;
-              try {
-                const parsedChunk = JSON.parse(newChunk);
-                controller.enqueue(parsedChunk);
-                failedChunk = void 0;
-              } catch {
-                failedChunk = newChunk;
-              }
-            }
-          }
-        } catch {
-        }
+    searchParams.set("runId", this.runId);
+    const requestContext = parseClientRequestContext(params.requestContext);
+    const response = await this.request(
+      `/api/workflows/${this.workflowId}/streamVNext?${searchParams.toString()}`,
+      {
+        method: "POST",
+        body: {
+          inputData: params.inputData,
+          initialState: params.initialState,
+          requestContext,
+          closeOnSuspend: params.closeOnSuspend,
+          tracingOptions: params.tracingOptions,
+          resourceId: params.resourceId
+        },
+        stream: true
       }
-    });
-    return response.body.pipeThrough(transformStream);
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to stream vNext workflow: ${response.statusText}`);
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    return response.body.pipeThrough(this.createChunkTransformStream());
   }
   /**
    * Observes workflow vNext stream for a workflow run
-   * @param params - Object containing the runId
    * @returns Promise containing the workflow execution results
    */
-  async observeStreamVNext(params) {
+  async observeStreamVNext() {
     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()}`,
       {
@@ -1998,40 +2857,16 @@ 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(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,
@@ -2039,16 +2874,16 @@ var Workflow = class extends BaseResource {
         requestContext,
         tracingOptions: params.tracingOptions
       }
-    });
+    }).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
+   * @param params - Object containing the step, resumeData and requestContext
    * @returns Promise containing the workflow resume results
    */
   async resumeStreamVNext(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()}`,
@@ -2069,63 +2904,16 @@ 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(transformStream);
-  }
-  /**
-   * Creates a new ReadableStream from an iterable or async iterable of objects,
-   * serializing each as JSON and separating them with the record separator (\x1E).
-   *
-   * @param records - An iterable or async iterable of objects to stream
-   * @returns A ReadableStream emitting the records as JSON strings separated by the record separator
-   */
-  static createRecordStream(records) {
-    const encoder = new TextEncoder();
-    return new ReadableStream({
-      async start(controller) {
-        try {
-          for await (const record of records) {
-            const json = JSON.stringify(record) + RECORD_SEPARATOR;
-            controller.enqueue(encoder.encode(json));
-          }
-          controller.close();
-        } catch (err) {
-          controller.error(err);
-        }
-      }
-    });
+    return response.body.pipeThrough(this.createChunkTransformStream());
   }
   /**
    * Restarts an active workflow run synchronously without waiting for the workflow to complete
-   * @param params - Object containing the runId and requestContext
+   * @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=${params.runId}`, {
+    return this.request(`/api/workflows/${this.workflowId}/restart?runId=${this.runId}`, {
       method: "POST",
       body: {
         requestContext,
@@ -2135,49 +2923,27 @@ var Workflow = class extends BaseResource {
   }
   /**
    * Restarts an active workflow run asynchronously
-   * @param params - Object containing the runId and requestContext
+   * @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=${params.runId}`, {
+    const requestContext = parseClientRequestContext(params?.requestContext);
+    return this.request(`/api/workflows/${this.workflowId}/restart-async?runId=${this.runId}`, {
       method: "POST",
       body: {
         requestContext,
-        tracingOptions: params.tracingOptions
+        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"
-    });
+    }).then(deserializeWorkflowError);
   }
   /**
    * 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
+   * @param params - Object containing the step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
    * @returns Promise containing success message
    */
-  timeTravel({
-    runId,
-    requestContext: paramsRequestContext,
-    ...params
-  }) {
+  timeTravel({ requestContext: paramsRequestContext, ...params }) {
     const requestContext = parseClientRequestContext(paramsRequestContext);
-    return this.request(`/api/workflows/${this.workflowId}/time-travel?runId=${runId}`, {
+    return this.request(`/api/workflows/${this.workflowId}/time-travel?runId=${this.runId}`, {
       method: "POST",
       body: {
         ...params,
@@ -2187,32 +2953,28 @@ var Workflow = class extends BaseResource {
   }
   /**
    * Time travels a workflow run asynchronously
-   * @param params - Object containing the runId, step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
+   * @param params - Object containing the step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
    * @returns Promise containing the workflow time travel results
    */
-  timeTravelAsync({
-    runId,
-    requestContext: paramsRequestContext,
-    ...params
-  }) {
+  timeTravelAsync({ requestContext: paramsRequestContext, ...params }) {
     const requestContext = parseClientRequestContext(paramsRequestContext);
-    return this.request(`/api/workflows/${this.workflowId}/time-travel-async?runId=${runId}`, {
+    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 runId, step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
+   * @param params - Object containing the step, inputData, resumeData, initialState, context, nestedStepsContext, requestContext and tracingOptions
    * @returns Promise containing the workflow execution results
    */
-  async timeTravelStream({ runId, requestContext: paramsRequestContext, ...params }) {
+  async timeTravelStream({ requestContext: paramsRequestContext, ...params }) {
     const requestContext = parseClientRequestContext(paramsRequestContext);
     const response = await this.request(
-      `/api/workflows/${this.workflowId}/time-travel-stream?runId=${runId}`,
+      `/api/workflows/${this.workflowId}/time-travel-stream?runId=${this.runId}`,
       {
         method: "POST",
         body: {
@@ -2228,31 +2990,159 @@ 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) {
+    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 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)}`);
+  }
+  /**
+   * 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"
+    });
+  }
+  /**
+   * 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 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., ['status', 'result']). Available fields: status, result, error, payload, steps, activeStepsPath, serializedStepGraph. Omitting this returns all fields.
+   * @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 execution result
+   */
+  runExecutionResult(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}/execution-result${queryString}`);
+  }
+  /**
+   * 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
+        }
+      }
+    );
+    const run = new Run(this.options, this.workflowId, res.runId);
+    return run;
+  }
+  /**
+   * Creates a new ReadableStream from an iterable or async iterable of objects,
+   * serializing each as JSON and separating them with the record separator (\x1E).
+   *
+   * @param records - An iterable or async iterable of objects to stream
+   * @returns A ReadableStream emitting the records as JSON strings separated by the record separator
+   */
+  static createRecordStream(records) {
+    const encoder = new TextEncoder();
+    return new ReadableStream({
+      async start(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;
-              }
-            }
+          for await (const record of records) {
+            const json = JSON.stringify(record) + RECORD_SEPARATOR2;
+            controller.enqueue(encoder.encode(json));
           }
-        } catch {
+          controller.close();
+        } catch (err) {
+          controller.error(err);
         }
       }
     });
-    return response.body.pipeThrough(transformStream);
   }
 };
 
@@ -2368,7 +3258,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);
@@ -2414,7 +3304,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;
@@ -2528,7 +3418,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) {
@@ -2789,7 +3679,7 @@ var Observability = class extends BaseResource {
   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));
@@ -2797,8 +3687,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));