@upstash/workflow 0.2.12 → 0.2.14

package/index.js

@@ -103,11 +103,12 @@ var WORKFLOW_PROTOCOL_VERSION_HEADER = "Upstash-Workflow-Sdk-Version";
 var DEFAULT_CONTENT_TYPE = "application/json";
 var NO_CONCURRENCY = 1;
 var DEFAULT_RETRIES = 3;
-var VERSION = "v0.2.7";
+var VERSION = "v0.2.14";
 var SDK_TELEMETRY = `@upstash/workflow@${VERSION}`;
 var TELEMETRY_HEADER_SDK = "Upstash-Telemetry-Sdk";
 var TELEMETRY_HEADER_FRAMEWORK = "Upstash-Telemetry-Framework";
 var TELEMETRY_HEADER_RUNTIME = "Upstash-Telemetry-Runtime";
+var TELEMETRY_HEADER_AGENT = "Upstash-Telemetry-Agent";
 
 // src/error.ts
 var import_qstash2 = require("@upstash/qstash");
@@ -150,6 +151,12 @@ var formatWorkflowError = (error) => {
   };
 };
 
+// src/context/auto-executor.ts
+var import_qstash5 = require("@upstash/qstash");
+
+// src/qstash/headers.ts
+var import_qstash4 = require("@upstash/qstash");
+
 // src/utils.ts
 var NANOID_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
 var NANOID_LENGTH = 21;
@@ -175,574 +182,231 @@ function decodeBase64(base64) {
   }
 }
 
-// src/context/steps.ts
-var BaseLazyStep = class _BaseLazyStep {
-  stepName;
-  constructor(stepName) {
-    if (!stepName) {
-      throw new WorkflowError(
-        "A workflow step name cannot be undefined or an empty string. Please provide a name for your workflow step."
-      );
-    }
-    this.stepName = stepName;
+// node_modules/neverthrow/dist/index.es.js
+var defaultErrorConfig = {
+  withStackTrace: false
+};
+var createNeverThrowError = (message, result, config = defaultErrorConfig) => {
+  const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
+  const maybeStack = config.withStackTrace ? new Error().stack : void 0;
+  return {
+    data,
+    message,
+    stack: maybeStack
+  };
+};
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
   }
-  /**
-   * parse the out field of a step result.
-   *
-   * will be called when returning the steps to the context from auto executor
-   *
-   * @param out field of the step
-   * @returns parsed out field
-   */
-  parseOut(out) {
-    if (out === void 0) {
-      if (this.allowUndefinedOut) {
-        return void 0;
-      } else {
-        throw new WorkflowError(
-          `Error while parsing output of ${this.stepType} step. Expected a string, but got: undefined`
-        );
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
       }
     }
-    if (typeof out === "object") {
-      if (this.stepType !== "Wait") {
-        console.warn(
-          `Error while parsing ${this.stepType} step output. Expected a string, but got object. Please reach out to Upstash Support.`
-        );
-        return out;
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
       }
-      return {
-        ...out,
-        eventData: _BaseLazyStep.tryParsing(out.eventData)
-      };
     }
-    if (typeof out !== "string") {
-      throw new WorkflowError(
-        `Error while parsing output of ${this.stepType} step. Expected a string or undefined, but got: ${typeof out}`
-      );
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
-    return this.safeParseOut(out);
-  }
-  safeParseOut(out) {
-    return _BaseLazyStep.tryParsing(out);
+    step((generator = generator.apply(thisArg, [])).next());
+  });
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function verb(n) {
+    if (g[n]) i[n] = function(v) {
+      return new Promise(function(a, b) {
+        q.push([n, v, a, b]) > 1 || resume(n, v);
+      });
+    };
   }
-  static tryParsing(stepOut) {
+  function resume(n, v) {
     try {
-      return JSON.parse(stepOut);
-    } catch {
-      return stepOut;
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
     }
   }
-};
-var LazyFunctionStep = class extends BaseLazyStep {
-  stepFunction;
-  stepType = "Run";
-  allowUndefinedOut = true;
-  constructor(stepName, stepFunction) {
-    super(stepName);
-    this.stepFunction = stepFunction;
+  function step(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
   }
-  getPlanStep(concurrent, targetStep) {
-    return {
-      stepId: 0,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      concurrent,
-      targetStep
-    };
+  function fulfill(value) {
+    resume("next", value);
   }
-  async getResultStep(concurrent, stepId) {
-    let result = this.stepFunction();
-    if (result instanceof Promise) {
-      result = await result;
-    }
-    return {
-      stepId,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      out: result,
-      concurrent
-    };
+  function reject(value) {
+    resume("throw", value);
   }
-};
-var LazySleepStep = class extends BaseLazyStep {
-  sleep;
-  stepType = "SleepFor";
-  allowUndefinedOut = true;
-  constructor(stepName, sleep) {
-    super(stepName);
-    this.sleep = sleep;
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
   }
-  getPlanStep(concurrent, targetStep) {
-    return {
-      stepId: 0,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      sleepFor: this.sleep,
-      concurrent,
-      targetStep
+}
+function __asyncDelegator(o) {
+  var i, p;
+  return i = {}, verb("next"), verb("throw", function(e) {
+    throw e;
+  }), verb("return"), i[Symbol.iterator] = function() {
+    return this;
+  }, i;
+  function verb(n, f) {
+    i[n] = o[n] ? function(v) {
+      return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v;
+    } : f;
+  }
+}
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
     };
   }
-  async getResultStep(concurrent, stepId) {
-    return await Promise.resolve({
-      stepId,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      sleepFor: this.sleep,
-      concurrent
-    });
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
   }
-};
-var LazySleepUntilStep = class extends BaseLazyStep {
-  sleepUntil;
-  stepType = "SleepUntil";
-  allowUndefinedOut = true;
-  constructor(stepName, sleepUntil) {
-    super(stepName);
-    this.sleepUntil = sleepUntil;
+}
+var ResultAsync = class _ResultAsync {
+  constructor(res) {
+    this._promise = res;
   }
-  getPlanStep(concurrent, targetStep) {
-    return {
-      stepId: 0,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      sleepUntil: this.sleepUntil,
-      concurrent,
-      targetStep
-    };
+  static fromSafePromise(promise) {
+    const newPromise = promise.then((value) => new Ok(value));
+    return new _ResultAsync(newPromise);
   }
-  async getResultStep(concurrent, stepId) {
-    return await Promise.resolve({
-      stepId,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      sleepUntil: this.sleepUntil,
-      concurrent
-    });
+  static fromPromise(promise, errorFn) {
+    const newPromise = promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e)));
+    return new _ResultAsync(newPromise);
   }
-  safeParseOut() {
-    return void 0;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromThrowable(fn, errorFn) {
+    return (...args) => {
+      return new _ResultAsync((() => __awaiter(this, void 0, void 0, function* () {
+        try {
+          return new Ok(yield fn(...args));
+        } catch (error) {
+          return new Err(errorFn ? errorFn(error) : error);
+        }
+      }))());
+    };
   }
-};
-var LazyCallStep = class _LazyCallStep extends BaseLazyStep {
-  url;
-  method;
-  body;
-  headers;
-  retries;
-  timeout;
-  flowControl;
-  stepType = "Call";
-  allowUndefinedOut = false;
-  constructor(stepName, url, method, body, headers, retries, timeout, flowControl) {
-    super(stepName);
-    this.url = url;
-    this.method = method;
-    this.body = body;
-    this.headers = headers;
-    this.retries = retries;
-    this.timeout = timeout;
-    this.flowControl = flowControl;
-  }
-  getPlanStep(concurrent, targetStep) {
-    return {
-      stepId: 0,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      concurrent,
-      targetStep
-    };
+  static combine(asyncResultList) {
+    return combineResultAsyncList(asyncResultList);
   }
-  async getResultStep(concurrent, stepId) {
-    return await Promise.resolve({
-      stepId,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      concurrent,
-      callUrl: this.url,
-      callMethod: this.method,
-      callBody: this.body,
-      callHeaders: this.headers
-    });
+  static combineWithAllErrors(asyncResultList) {
+    return combineResultAsyncListWithAllErrors(asyncResultList);
   }
-  safeParseOut(out) {
-    const { header, status, body } = JSON.parse(out);
-    const responseHeaders = new Headers(header);
-    if (_LazyCallStep.isText(responseHeaders.get("content-type"))) {
-      const bytes = new Uint8Array(out.length);
-      for (let i = 0; i < out.length; i++) {
-        bytes[i] = out.charCodeAt(i);
+  map(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
       }
-      const processedResult = new TextDecoder().decode(bytes);
-      const newBody = JSON.parse(processedResult).body;
-      return {
-        status,
-        header,
-        body: BaseLazyStep.tryParsing(newBody)
-      };
-    } else {
-      return { header, status, body };
-    }
-  }
-  static applicationHeaders = /* @__PURE__ */ new Set([
-    "application/json",
-    "application/xml",
-    "application/javascript",
-    "application/x-www-form-urlencoded",
-    "application/xhtml+xml",
-    "application/ld+json",
-    "application/rss+xml",
-    "application/atom+xml"
-  ]);
-  static isText = (contentTypeHeader) => {
-    if (!contentTypeHeader) {
-      return false;
-    }
-    if (_LazyCallStep.applicationHeaders.has(contentTypeHeader)) {
-      return true;
-    }
-    if (contentTypeHeader.startsWith("text/")) {
-      return true;
-    }
-    return false;
-  };
-};
-var LazyWaitForEventStep = class extends BaseLazyStep {
-  eventId;
-  timeout;
-  stepType = "Wait";
-  allowUndefinedOut = false;
-  constructor(stepName, eventId, timeout) {
-    super(stepName);
-    this.eventId = eventId;
-    this.timeout = timeout;
+      return new Ok(yield f(res.value));
+    })));
   }
-  getPlanStep(concurrent, targetStep) {
-    return {
-      stepId: 0,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      waitEventId: this.eventId,
-      timeout: this.timeout,
-      concurrent,
-      targetStep
-    };
+  andThrough(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      const newRes = yield f(res.value);
+      if (newRes.isErr()) {
+        return new Err(newRes.error);
+      }
+      return new Ok(res.value);
+    })));
   }
-  async getResultStep(concurrent, stepId) {
-    return await Promise.resolve({
-      stepId,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      waitEventId: this.eventId,
-      timeout: this.timeout,
-      concurrent
-    });
+  andTee(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      try {
+        yield f(res.value);
+      } catch (e) {
+      }
+      return new Ok(res.value);
+    })));
   }
-  safeParseOut(out) {
-    const result = JSON.parse(out);
-    return {
-      ...result,
-      eventData: BaseLazyStep.tryParsing(result.eventData)
-    };
+  mapErr(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isOk()) {
+        return new Ok(res.value);
+      }
+      return new Err(yield f(res.error));
+    })));
   }
-};
-var LazyNotifyStep = class extends LazyFunctionStep {
-  stepType = "Notify";
-  constructor(stepName, eventId, eventData, requester) {
-    super(stepName, async () => {
-      const notifyResponse = await makeNotifyRequest(requester, eventId, eventData);
-      return {
-        eventId,
-        eventData,
-        notifyResponse
-      };
-    });
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(f) {
+    return new _ResultAsync(this._promise.then((res) => {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      const newValue = f(res.value);
+      return newValue instanceof _ResultAsync ? newValue._promise : newValue;
+    }));
   }
-  safeParseOut(out) {
-    const result = JSON.parse(out);
-    return {
-      ...result,
-      eventData: BaseLazyStep.tryParsing(result.eventData)
-    };
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return f(res.error);
+      }
+      return new Ok(res.value);
+    })));
   }
-};
-var LazyInvokeStep = class extends BaseLazyStep {
-  stepType = "Invoke";
-  params;
-  allowUndefinedOut = false;
-  constructor(stepName, {
-    workflow,
-    body,
-    headers = {},
-    workflowRunId,
-    retries,
-    flowControl
-  }) {
-    super(stepName);
-    this.params = {
-      workflow,
-      body,
-      headers,
-      workflowRunId: getWorkflowRunId(workflowRunId),
-      retries,
-      flowControl
-    };
+  match(ok2, _err) {
+    return this._promise.then((res) => res.match(ok2, _err));
   }
-  getPlanStep(concurrent, targetStep) {
-    return {
-      stepId: 0,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      concurrent,
-      targetStep
-    };
+  unwrapOr(t) {
+    return this._promise.then((res) => res.unwrapOr(t));
   }
   /**
-   * won't be used as it's the server who will add the result step
-   * in Invoke step.
+   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
    */
-  getResultStep(concurrent, stepId) {
-    return Promise.resolve({
-      stepId,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      concurrent
+  safeUnwrap() {
+    return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
+      return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
     });
   }
-  safeParseOut(out) {
-    const result = JSON.parse(out);
-    return {
-      ...result,
-      body: BaseLazyStep.tryParsing(result.body)
-    };
-  }
-};
-
-// node_modules/neverthrow/dist/index.es.js
-var defaultErrorConfig = {
-  withStackTrace: false
-};
-var createNeverThrowError = (message, result, config = defaultErrorConfig) => {
-  const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
-  const maybeStack = config.withStackTrace ? new Error().stack : void 0;
-  return {
-    data,
-    message,
-    stack: maybeStack
-  };
-};
-function __awaiter(thisArg, _arguments, P, generator) {
-  function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve) {
-      resolve(value);
-    });
-  }
-  return new (P || (P = Promise))(function(resolve, reject) {
-    function fulfilled(value) {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function rejected(value) {
-      try {
-        step(generator["throw"](value));
-      } catch (e) {
-        reject(e);
-      }
-    }
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-    }
-    step((generator = generator.apply(thisArg, [])).next());
-  });
-}
-function __values(o) {
-  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-  if (m) return m.call(o);
-  if (o && typeof o.length === "number") return {
-    next: function() {
-      if (o && i >= o.length) o = void 0;
-      return { value: o && o[i++], done: !o };
-    }
-  };
-  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-function __await(v) {
-  return this instanceof __await ? (this.v = v, this) : new __await(v);
-}
-function __asyncGenerator(thisArg, _arguments, generator) {
-  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-  var g = generator.apply(thisArg, _arguments || []), i, q = [];
-  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
-    return this;
-  }, i;
-  function verb(n) {
-    if (g[n]) i[n] = function(v) {
-      return new Promise(function(a, b) {
-        q.push([n, v, a, b]) > 1 || resume(n, v);
-      });
-    };
-  }
-  function resume(n, v) {
-    try {
-      step(g[n](v));
-    } catch (e) {
-      settle(q[0][3], e);
-    }
-  }
-  function step(r) {
-    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
-  }
-  function fulfill(value) {
-    resume("next", value);
-  }
-  function reject(value) {
-    resume("throw", value);
-  }
-  function settle(f, v) {
-    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
-  }
-}
-function __asyncDelegator(o) {
-  var i, p;
-  return i = {}, verb("next"), verb("throw", function(e) {
-    throw e;
-  }), verb("return"), i[Symbol.iterator] = function() {
-    return this;
-  }, i;
-  function verb(n, f) {
-    i[n] = o[n] ? function(v) {
-      return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v;
-    } : f;
-  }
-}
-function __asyncValues(o) {
-  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-  var m = o[Symbol.asyncIterator], i;
-  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
-    return this;
-  }, i);
-  function verb(n) {
-    i[n] = o[n] && function(v) {
-      return new Promise(function(resolve, reject) {
-        v = o[n](v), settle(resolve, reject, v.done, v.value);
-      });
-    };
-  }
-  function settle(resolve, reject, d, v) {
-    Promise.resolve(v).then(function(v2) {
-      resolve({ value: v2, done: d });
-    }, reject);
-  }
-}
-var ResultAsync = class _ResultAsync {
-  constructor(res) {
-    this._promise = res;
-  }
-  static fromSafePromise(promise) {
-    const newPromise = promise.then((value) => new Ok(value));
-    return new _ResultAsync(newPromise);
-  }
-  static fromPromise(promise, errorFn) {
-    const newPromise = promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e)));
-    return new _ResultAsync(newPromise);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static fromThrowable(fn, errorFn) {
-    return (...args) => {
-      return new _ResultAsync((() => __awaiter(this, void 0, void 0, function* () {
-        try {
-          return new Ok(yield fn(...args));
-        } catch (error) {
-          return new Err(errorFn ? errorFn(error) : error);
-        }
-      }))());
-    };
-  }
-  static combine(asyncResultList) {
-    return combineResultAsyncList(asyncResultList);
-  }
-  static combineWithAllErrors(asyncResultList) {
-    return combineResultAsyncListWithAllErrors(asyncResultList);
-  }
-  map(f) {
-    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
-      if (res.isErr()) {
-        return new Err(res.error);
-      }
-      return new Ok(yield f(res.value));
-    })));
-  }
-  andThrough(f) {
-    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
-      if (res.isErr()) {
-        return new Err(res.error);
-      }
-      const newRes = yield f(res.value);
-      if (newRes.isErr()) {
-        return new Err(newRes.error);
-      }
-      return new Ok(res.value);
-    })));
-  }
-  andTee(f) {
-    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
-      if (res.isErr()) {
-        return new Err(res.error);
-      }
-      try {
-        yield f(res.value);
-      } catch (e) {
-      }
-      return new Ok(res.value);
-    })));
-  }
-  mapErr(f) {
-    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
-      if (res.isOk()) {
-        return new Ok(res.value);
-      }
-      return new Err(yield f(res.error));
-    })));
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-  andThen(f) {
-    return new _ResultAsync(this._promise.then((res) => {
-      if (res.isErr()) {
-        return new Err(res.error);
-      }
-      const newValue = f(res.value);
-      return newValue instanceof _ResultAsync ? newValue._promise : newValue;
-    }));
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-  orElse(f) {
-    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
-      if (res.isErr()) {
-        return f(res.error);
-      }
-      return new Ok(res.value);
-    })));
-  }
-  match(ok2, _err) {
-    return this._promise.then((res) => res.match(ok2, _err));
-  }
-  unwrapOr(t) {
-    return this._promise.then((res) => res.unwrapOr(t));
-  }
-  /**
-   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
-   */
-  safeUnwrap() {
-    return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
-      return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
-    });
-  }
-  // Makes ResultAsync implement PromiseLike<Result>
-  then(successCallback, failureCallback) {
-    return this._promise.then(successCallback, failureCallback);
+  // Makes ResultAsync implement PromiseLike<Result>
+  then(successCallback, failureCallback) {
+    return this._promise.then(successCallback, failureCallback);
   }
 };
 var errAsync = (err2) => new ResultAsync(Promise.resolve(new Err(err2)));
@@ -947,54 +611,72 @@ var StepTypes = [
 
 // src/workflow-requests.ts
 var import_qstash3 = require("@upstash/qstash");
-var triggerFirstInvocation = async ({
-  workflowContext,
-  useJSONContent,
-  telemetry,
-  debug,
-  invokeCount
-}) => {
-  const { headers } = getHeaders({
-    initHeaderValue: "true",
-    workflowRunId: workflowContext.workflowRunId,
-    workflowUrl: workflowContext.url,
-    userHeaders: workflowContext.headers,
-    failureUrl: workflowContext.failureUrl,
-    retries: workflowContext.retries,
-    telemetry,
-    invokeCount,
-    flowControl: workflowContext.flowControl
-  });
-  if (workflowContext.headers.get("content-type")) {
-    headers["content-type"] = workflowContext.headers.get("content-type");
-  }
-  if (useJSONContent) {
-    headers["content-type"] = "application/json";
-  }
-  try {
-    const body = typeof workflowContext.requestPayload === "string" ? workflowContext.requestPayload : JSON.stringify(workflowContext.requestPayload);
-    const result = await workflowContext.qstashClient.publish({
-      headers,
-      method: "POST",
-      body,
-      url: workflowContext.url
-    });
-    if (result.deduplicated) {
-      await debug?.log("WARN", "SUBMIT_FIRST_INVOCATION", {
-        message: `Workflow run ${workflowContext.workflowRunId} already exists. A new one isn't created.`,
+var triggerFirstInvocation = async (params) => {
+  const firstInvocationParams = Array.isArray(params) ? params : [params];
+  const workflowContextClient = firstInvocationParams[0].workflowContext.qstashClient;
+  const invocationBatch = firstInvocationParams.map(
+    ({ workflowContext, useJSONContent, telemetry, invokeCount, delay }) => {
+      const { headers } = getHeaders({
+        initHeaderValue: "true",
+        workflowConfig: {
+          workflowRunId: workflowContext.workflowRunId,
+          workflowUrl: workflowContext.url,
+          failureUrl: workflowContext.failureUrl,
+          retries: workflowContext.retries,
+          telemetry,
+          flowControl: workflowContext.flowControl,
+          useJSONContent: useJSONContent ?? false
+        },
+        invokeCount: invokeCount ?? 0,
+        userHeaders: workflowContext.headers
+      });
+      if (workflowContext.headers.get("content-type")) {
+        headers["content-type"] = workflowContext.headers.get("content-type");
+      }
+      if (useJSONContent) {
+        headers["content-type"] = "application/json";
+      }
+      const body = typeof workflowContext.requestPayload === "string" ? workflowContext.requestPayload : JSON.stringify(workflowContext.requestPayload);
+      return {
         headers,
-        requestPayload: workflowContext.requestPayload,
+        method: "POST",
+        body,
         url: workflowContext.url,
-        messageId: result.messageId
-      });
+        delay
+      };
+    }
+  );
+  try {
+    const results = await workflowContextClient.batch(invocationBatch);
+    const invocationStatuses = [];
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      const invocationParams = firstInvocationParams[i];
+      if (result.deduplicated) {
+        await invocationParams.debug?.log("WARN", "SUBMIT_FIRST_INVOCATION", {
+          message: `Workflow run ${invocationParams.workflowContext.workflowRunId} already exists. A new one isn't created.`,
+          headers: invocationBatch[i].headers,
+          requestPayload: invocationParams.workflowContext.requestPayload,
+          url: invocationParams.workflowContext.url,
+          messageId: result.messageId
+        });
+        invocationStatuses.push("workflow-run-already-exists");
+      } else {
+        await invocationParams.debug?.log("SUBMIT", "SUBMIT_FIRST_INVOCATION", {
+          headers: invocationBatch[i].headers,
+          requestPayload: invocationParams.workflowContext.requestPayload,
+          url: invocationParams.workflowContext.url,
+          messageId: result.messageId
+        });
+        invocationStatuses.push("success");
+      }
+    }
+    const hasAnyDeduplicated = invocationStatuses.some(
+      (status) => status === "workflow-run-already-exists"
+    );
+    if (hasAnyDeduplicated) {
       return ok("workflow-run-already-exists");
     } else {
-      await debug?.log("SUBMIT", "SUBMIT_FIRST_INVOCATION", {
-        headers,
-        requestPayload: workflowContext.requestPayload,
-        url: workflowContext.url,
-        messageId: result.messageId
-      });
       return ok("success");
     }
   } catch (error) {
@@ -1133,14 +815,16 @@ ${atob(callbackMessage.body ?? "")}`
       const userHeaders = recreateUserHeaders(request.headers);
       const { headers: requestHeaders } = getHeaders({
         initHeaderValue: "false",
-        workflowRunId,
-        workflowUrl,
+        workflowConfig: {
+          workflowRunId,
+          workflowUrl,
+          failureUrl,
+          retries,
+          telemetry,
+          flowControl
+        },
         userHeaders,
-        failureUrl,
-        retries,
-        telemetry,
-        invokeCount: Number(invokeCount),
-        flowControl
+        invokeCount: Number(invokeCount)
       });
       const callResponse = {
         status: callbackMessage.status,
@@ -1172,282 +856,913 @@ ${atob(callbackMessage.body ?? "")}`
     } else {
       return ok("continue-workflow");
     }
-  } catch (error) {
-    const isCallReturn = request.headers.get("Upstash-Workflow-Callback");
-    return err(
-      new WorkflowError(`Error when handling call return (isCallReturn=${isCallReturn}): ${error}`)
-    );
+  } catch (error) {
+    const isCallReturn = request.headers.get("Upstash-Workflow-Callback");
+    return err(
+      new WorkflowError(`Error when handling call return (isCallReturn=${isCallReturn}): ${error}`)
+    );
+  }
+};
+var getTelemetryHeaders = (telemetry) => {
+  return {
+    [TELEMETRY_HEADER_SDK]: telemetry.sdk,
+    [TELEMETRY_HEADER_FRAMEWORK]: telemetry.framework,
+    [TELEMETRY_HEADER_RUNTIME]: telemetry.runtime ?? "unknown"
+  };
+};
+var verifyRequest = async (body, signature, verifier) => {
+  if (!verifier) {
+    return;
+  }
+  try {
+    if (!signature) {
+      throw new Error("`Upstash-Signature` header is not passed.");
+    }
+    const isValid = await verifier.verify({
+      body,
+      signature
+    });
+    if (!isValid) {
+      throw new Error("Signature in `Upstash-Signature` header is not valid");
+    }
+  } catch (error) {
+    throw new WorkflowError(
+      `Failed to verify that the Workflow request comes from QStash: ${error}
+
+If signature is missing, trigger the workflow endpoint by publishing your request to QStash instead of calling it directly.
+
+If you want to disable QStash Verification, you should clear env variables QSTASH_CURRENT_SIGNING_KEY and QSTASH_NEXT_SIGNING_KEY`
+    );
+  }
+};
+
+// src/context/steps.ts
+var BaseLazyStep = class _BaseLazyStep {
+  stepName;
+  constructor(stepName) {
+    if (!stepName) {
+      throw new WorkflowError(
+        "A workflow step name cannot be undefined or an empty string. Please provide a name for your workflow step."
+      );
+    }
+    if (typeof stepName !== "string") {
+      console.warn(
+        "Workflow Warning: A workflow step name must be a string. In a future release, this will throw an error."
+      );
+    }
+    this.stepName = stepName;
+  }
+  /**
+   * parse the out field of a step result.
+   *
+   * will be called when returning the steps to the context from auto executor
+   *
+   * @param out field of the step
+   * @returns parsed out field
+   */
+  parseOut(out) {
+    if (out === void 0) {
+      if (this.allowUndefinedOut) {
+        return void 0;
+      } else {
+        throw new WorkflowError(
+          `Error while parsing output of ${this.stepType} step. Expected a string, but got: undefined`
+        );
+      }
+    }
+    if (typeof out === "object") {
+      if (this.stepType !== "Wait") {
+        console.warn(
+          `Error while parsing ${this.stepType} step output. Expected a string, but got object. Please reach out to Upstash Support.`
+        );
+        return out;
+      }
+      return {
+        ...out,
+        eventData: _BaseLazyStep.tryParsing(out.eventData)
+      };
+    }
+    if (typeof out !== "string") {
+      throw new WorkflowError(
+        `Error while parsing output of ${this.stepType} step. Expected a string or undefined, but got: ${typeof out}`
+      );
+    }
+    return this.safeParseOut(out);
+  }
+  safeParseOut(out) {
+    return _BaseLazyStep.tryParsing(out);
+  }
+  static tryParsing(stepOut) {
+    try {
+      return JSON.parse(stepOut);
+    } catch {
+      return stepOut;
+    }
+  }
+  getBody({ step }) {
+    step.out = JSON.stringify(step.out);
+    return JSON.stringify(step);
+  }
+  getHeaders({ context, telemetry, invokeCount, step }) {
+    return getHeaders({
+      initHeaderValue: "false",
+      workflowConfig: {
+        workflowRunId: context.workflowRunId,
+        workflowUrl: context.url,
+        failureUrl: context.failureUrl,
+        retries: context.retries,
+        useJSONContent: false,
+        telemetry,
+        flowControl: context.flowControl
+      },
+      userHeaders: context.headers,
+      invokeCount,
+      stepInfo: {
+        step,
+        lazyStep: this
+      }
+    });
+  }
+  async submitStep({ context, body, headers }) {
+    return await context.qstashClient.batch([
+      {
+        body,
+        headers,
+        method: "POST",
+        url: context.url
+      }
+    ]);
+  }
+};
+var LazyFunctionStep = class extends BaseLazyStep {
+  stepFunction;
+  stepType = "Run";
+  allowUndefinedOut = true;
+  constructor(stepName, stepFunction) {
+    super(stepName);
+    this.stepFunction = stepFunction;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    let result = this.stepFunction();
+    if (result instanceof Promise) {
+      result = await result;
+    }
+    return {
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      out: result,
+      concurrent
+    };
+  }
+};
+var LazySleepStep = class extends BaseLazyStep {
+  sleep;
+  stepType = "SleepFor";
+  allowUndefinedOut = true;
+  constructor(stepName, sleep) {
+    super(stepName);
+    this.sleep = sleep;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      sleepFor: this.sleep,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      sleepFor: this.sleep,
+      concurrent
+    });
+  }
+  async submitStep({ context, body, headers, isParallel }) {
+    return await context.qstashClient.batch([
+      {
+        body,
+        headers,
+        method: "POST",
+        url: context.url,
+        delay: isParallel ? void 0 : this.sleep
+      }
+    ]);
+  }
+};
+var LazySleepUntilStep = class extends BaseLazyStep {
+  sleepUntil;
+  stepType = "SleepUntil";
+  allowUndefinedOut = true;
+  constructor(stepName, sleepUntil) {
+    super(stepName);
+    this.sleepUntil = sleepUntil;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      sleepUntil: this.sleepUntil,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      sleepUntil: this.sleepUntil,
+      concurrent
+    });
+  }
+  safeParseOut() {
+    return void 0;
+  }
+  async submitStep({ context, body, headers, isParallel }) {
+    return await context.qstashClient.batch([
+      {
+        body,
+        headers,
+        method: "POST",
+        url: context.url,
+        notBefore: isParallel ? void 0 : this.sleepUntil
+      }
+    ]);
+  }
+};
+var LazyCallStep = class _LazyCallStep extends BaseLazyStep {
+  url;
+  method;
+  body;
+  headers;
+  retries;
+  timeout;
+  flowControl;
+  stepType = "Call";
+  allowUndefinedOut = false;
+  constructor(stepName, url, method, body, headers, retries, timeout, flowControl) {
+    super(stepName);
+    this.url = url;
+    this.method = method;
+    this.body = body;
+    this.headers = headers;
+    this.retries = retries;
+    this.timeout = timeout;
+    this.flowControl = flowControl;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      concurrent,
+      callUrl: this.url,
+      callMethod: this.method,
+      callBody: this.body,
+      callHeaders: this.headers
+    });
+  }
+  safeParseOut(out) {
+    const { header, status, body } = JSON.parse(out);
+    const responseHeaders = new Headers(header);
+    if (_LazyCallStep.isText(responseHeaders.get("content-type"))) {
+      const bytes = new Uint8Array(out.length);
+      for (let i = 0; i < out.length; i++) {
+        bytes[i] = out.charCodeAt(i);
+      }
+      const processedResult = new TextDecoder().decode(bytes);
+      const newBody = JSON.parse(processedResult).body;
+      return {
+        status,
+        header,
+        body: BaseLazyStep.tryParsing(newBody)
+      };
+    } else {
+      return { header, status, body };
+    }
+  }
+  static applicationContentTypes = [
+    "application/json",
+    "application/xml",
+    "application/javascript",
+    "application/x-www-form-urlencoded",
+    "application/xhtml+xml",
+    "application/ld+json",
+    "application/rss+xml",
+    "application/atom+xml"
+  ];
+  static isText = (contentTypeHeader) => {
+    if (!contentTypeHeader) {
+      return false;
+    }
+    if (_LazyCallStep.applicationContentTypes.some((type) => contentTypeHeader.includes(type))) {
+      return true;
+    }
+    if (contentTypeHeader.startsWith("text/")) {
+      return true;
+    }
+    return false;
+  };
+  getBody({ step }) {
+    if (!step.callUrl) {
+      throw new WorkflowError("Incompatible step received in LazyCallStep.getBody");
+    }
+    return JSON.stringify(step.callBody);
+  }
+  getHeaders({ context, telemetry, invokeCount, step }) {
+    const { headers, contentType } = super.getHeaders({ context, telemetry, invokeCount, step });
+    headers["Upstash-Retries"] = this.retries.toString();
+    headers[WORKFLOW_FEATURE_HEADER] = "WF_NoDelete,InitialBody";
+    if (this.flowControl) {
+      const { flowControlKey, flowControlValue } = prepareFlowControl(this.flowControl);
+      headers["Upstash-Flow-Control-Key"] = flowControlKey;
+      headers["Upstash-Flow-Control-Value"] = flowControlValue;
+    }
+    if (this.timeout) {
+      headers["Upstash-Timeout"] = this.timeout.toString();
+    }
+    const forwardedHeaders = Object.fromEntries(
+      Object.entries(this.headers).map(([header, value]) => [`Upstash-Forward-${header}`, value])
+    );
+    return {
+      headers: {
+        ...headers,
+        ...forwardedHeaders,
+        "Upstash-Callback": context.url,
+        "Upstash-Callback-Workflow-RunId": context.workflowRunId,
+        "Upstash-Callback-Workflow-CallType": "fromCallback",
+        "Upstash-Callback-Workflow-Init": "false",
+        "Upstash-Callback-Workflow-Url": context.url,
+        "Upstash-Callback-Feature-Set": "LazyFetch,InitialBody",
+        "Upstash-Callback-Forward-Upstash-Workflow-Callback": "true",
+        "Upstash-Callback-Forward-Upstash-Workflow-StepId": step.stepId.toString(),
+        "Upstash-Callback-Forward-Upstash-Workflow-StepName": this.stepName,
+        "Upstash-Callback-Forward-Upstash-Workflow-StepType": this.stepType,
+        "Upstash-Callback-Forward-Upstash-Workflow-Concurrent": step.concurrent.toString(),
+        "Upstash-Callback-Forward-Upstash-Workflow-ContentType": contentType,
+        "Upstash-Workflow-CallType": "toCallback"
+      },
+      contentType
+    };
+  }
+  async submitStep({ context, headers }) {
+    return await context.qstashClient.batch([
+      {
+        headers,
+        body: JSON.stringify(this.body),
+        method: this.method,
+        url: this.url
+      }
+    ]);
+  }
+};
+var LazyWaitForEventStep = class extends BaseLazyStep {
+  eventId;
+  timeout;
+  stepType = "Wait";
+  allowUndefinedOut = false;
+  constructor(stepName, eventId, timeout) {
+    super(stepName);
+    this.eventId = eventId;
+    this.timeout = timeout;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      waitEventId: this.eventId,
+      timeout: this.timeout,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      waitEventId: this.eventId,
+      timeout: this.timeout,
+      concurrent
+    });
+  }
+  safeParseOut(out) {
+    const result = JSON.parse(out);
+    return {
+      ...result,
+      eventData: BaseLazyStep.tryParsing(result.eventData)
+    };
+  }
+  getHeaders({ context, telemetry, invokeCount, step }) {
+    const headers = super.getHeaders({ context, telemetry, invokeCount, step });
+    headers.headers["Upstash-Workflow-CallType"] = "step";
+    return headers;
+  }
+  getBody({ context, step, headers, telemetry }) {
+    if (!step.waitEventId) {
+      throw new WorkflowError("Incompatible step received in LazyWaitForEventStep.getBody");
+    }
+    const timeoutHeaders = {
+      // to include user headers:
+      ...Object.fromEntries(Object.entries(headers).map(([header, value]) => [header, [value]])),
+      // to include telemetry headers:
+      ...telemetry ? Object.fromEntries(
+        Object.entries(getTelemetryHeaders(telemetry)).map(([header, value]) => [
+          header,
+          [value]
+        ])
+      ) : {},
+      // note: using WORKFLOW_ID_HEADER doesn't work, because Runid -> RunId:
+      "Upstash-Workflow-Runid": [context.workflowRunId],
+      [WORKFLOW_INIT_HEADER]: ["false"],
+      [WORKFLOW_URL_HEADER]: [context.url],
+      "Upstash-Workflow-CallType": ["step"]
+    };
+    const waitBody = {
+      url: context.url,
+      timeout: step.timeout,
+      timeoutBody: void 0,
+      timeoutUrl: context.url,
+      timeoutHeaders,
+      step: {
+        stepId: step.stepId,
+        stepType: "Wait",
+        stepName: step.stepName,
+        concurrent: step.concurrent,
+        targetStep: step.targetStep
+      }
+    };
+    return JSON.stringify(waitBody);
+  }
+  async submitStep({ context, body, headers }) {
+    const result = await context.qstashClient.http.request({
+      path: ["v2", "wait", this.eventId],
+      body,
+      headers,
+      method: "POST",
+      parseResponseAsJson: false
+    });
+    return [result];
+  }
+};
+var LazyNotifyStep = class extends LazyFunctionStep {
+  stepType = "Notify";
+  constructor(stepName, eventId, eventData, requester) {
+    super(stepName, async () => {
+      const notifyResponse = await makeNotifyRequest(requester, eventId, eventData);
+      return {
+        eventId,
+        eventData,
+        notifyResponse
+      };
+    });
+  }
+  safeParseOut(out) {
+    const result = JSON.parse(out);
+    return {
+      ...result,
+      eventData: BaseLazyStep.tryParsing(result.eventData)
+    };
+  }
+};
+var LazyInvokeStep = class extends BaseLazyStep {
+  stepType = "Invoke";
+  params;
+  allowUndefinedOut = false;
+  /**
+   * workflow id of the invoked workflow
+   */
+  workflowId;
+  constructor(stepName, {
+    workflow,
+    body,
+    headers = {},
+    workflowRunId,
+    retries,
+    flowControl
+  }) {
+    super(stepName);
+    this.params = {
+      workflow,
+      body,
+      headers,
+      workflowRunId: getWorkflowRunId(workflowRunId),
+      retries,
+      flowControl
+    };
+    const { workflowId } = workflow;
+    if (!workflowId) {
+      throw new WorkflowError("You can only invoke workflow which has a workflowId");
+    }
+    this.workflowId = workflowId;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      concurrent,
+      targetStep
+    };
+  }
+  /**
+   * won't be used as it's the server who will add the result step
+   * in Invoke step.
+   */
+  getResultStep(concurrent, stepId) {
+    return Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      concurrent
+    });
+  }
+  safeParseOut(out) {
+    const result = JSON.parse(out);
+    return {
+      ...result,
+      body: BaseLazyStep.tryParsing(result.body)
+    };
+  }
+  getBody({ context, step, telemetry, invokeCount }) {
+    const { headers: invokerHeaders } = getHeaders({
+      initHeaderValue: "false",
+      workflowConfig: {
+        workflowRunId: context.workflowRunId,
+        workflowUrl: context.url,
+        failureUrl: context.failureUrl,
+        retries: context.retries,
+        telemetry,
+        flowControl: context.flowControl,
+        useJSONContent: false
+      },
+      userHeaders: context.headers,
+      invokeCount
+    });
+    invokerHeaders["Upstash-Workflow-Runid"] = context.workflowRunId;
+    const request = {
+      body: JSON.stringify(this.params.body),
+      headers: Object.fromEntries(
+        Object.entries(invokerHeaders).map((pairs) => [pairs[0], [pairs[1]]])
+      ),
+      workflowRunId: context.workflowRunId,
+      workflowUrl: context.url,
+      step
+    };
+    return JSON.stringify(request);
+  }
+  getHeaders({ context, telemetry, invokeCount }) {
+    const {
+      workflow,
+      headers = {},
+      workflowRunId = getWorkflowRunId(),
+      retries,
+      flowControl
+    } = this.params;
+    const newUrl = context.url.replace(/[^/]+$/, this.workflowId);
+    const {
+      retries: workflowRetries,
+      failureFunction,
+      failureUrl,
+      useJSONContent,
+      flowControl: workflowFlowControl
+    } = workflow.options;
+    const { headers: triggerHeaders, contentType } = getHeaders({
+      initHeaderValue: "true",
+      workflowConfig: {
+        workflowRunId,
+        workflowUrl: newUrl,
+        retries: retries ?? workflowRetries,
+        telemetry,
+        failureUrl: failureFunction ? newUrl : failureUrl,
+        flowControl: flowControl ?? workflowFlowControl,
+        useJSONContent: useJSONContent ?? false
+      },
+      invokeCount: invokeCount + 1,
+      userHeaders: new Headers(headers)
+    });
+    triggerHeaders["Upstash-Workflow-Invoke"] = "true";
+    return { headers: triggerHeaders, contentType };
+  }
+  async submitStep({ context, body, headers }) {
+    const newUrl = context.url.replace(/[^/]+$/, this.workflowId);
+    const result = await context.qstashClient.publish({
+      headers,
+      method: "POST",
+      body,
+      url: newUrl
+    });
+    return [result];
+  }
+};
+
+// src/agents/constants.ts
+var AGENT_NAME_HEADER = "upstash-agent-name";
+var MANAGER_AGENT_PROMPT = `You are an agent orchestrating other AI Agents.
+
+These other agents have tools available to them.
+
+Given a prompt, utilize these agents to address requests.
+
+Don't always call all the agents provided to you at the same time. You can call one and use it's response to call another.
+
+Avoid calling the same agent twice in one turn. Instead, prefer to call it once but provide everything
+you need from that agent.
+`;
+
+// src/qstash/headers.ts
+var WorkflowHeaders = class {
+  userHeaders;
+  workflowConfig;
+  invokeCount;
+  initHeaderValue;
+  stepInfo;
+  headers;
+  constructor({
+    userHeaders,
+    workflowConfig,
+    invokeCount,
+    initHeaderValue,
+    stepInfo
+  }) {
+    this.userHeaders = userHeaders;
+    this.workflowConfig = workflowConfig;
+    this.invokeCount = invokeCount;
+    this.initHeaderValue = initHeaderValue;
+    this.stepInfo = stepInfo;
+    this.headers = {
+      rawHeaders: {},
+      workflowHeaders: {},
+      failureHeaders: {}
+    };
+  }
+  getHeaders() {
+    this.addBaseHeaders();
+    this.addRetries();
+    this.addFlowControl();
+    this.addUserHeaders();
+    this.addInvokeCount();
+    this.addFailureUrl();
+    const contentType = this.addContentType();
+    return this.prefixHeaders(contentType);
+  }
+  addBaseHeaders() {
+    this.headers.rawHeaders = {
+      ...this.headers.rawHeaders,
+      [WORKFLOW_INIT_HEADER]: this.initHeaderValue,
+      [WORKFLOW_ID_HEADER]: this.workflowConfig.workflowRunId,
+      [WORKFLOW_URL_HEADER]: this.workflowConfig.workflowUrl,
+      [WORKFLOW_FEATURE_HEADER]: "LazyFetch,InitialBody",
+      [WORKFLOW_PROTOCOL_VERSION_HEADER]: WORKFLOW_PROTOCOL_VERSION,
+      ...this.workflowConfig.telemetry ? getTelemetryHeaders(this.workflowConfig.telemetry) : {},
+      ...this.workflowConfig.telemetry && this.stepInfo?.lazyStep instanceof LazyCallStep && this.stepInfo.lazyStep.headers[AGENT_NAME_HEADER] ? { [TELEMETRY_HEADER_AGENT]: "true" } : {}
+    };
+    if (this.stepInfo?.lazyStep.stepType !== "Call") {
+      this.headers.rawHeaders[`Upstash-Forward-${WORKFLOW_PROTOCOL_VERSION_HEADER}`] = WORKFLOW_PROTOCOL_VERSION;
+    }
   }
-};
-var getTelemetryHeaders = (telemetry) => {
-  return {
-    [TELEMETRY_HEADER_SDK]: telemetry.sdk,
-    [TELEMETRY_HEADER_FRAMEWORK]: telemetry.framework,
-    [TELEMETRY_HEADER_RUNTIME]: telemetry.runtime ?? "unknown"
-  };
-};
-var getHeaders = ({
-  initHeaderValue,
-  workflowRunId,
-  workflowUrl,
-  userHeaders,
-  failureUrl,
-  retries,
-  step,
-  callRetries,
-  callTimeout,
-  telemetry,
-  invokeCount,
-  flowControl,
-  callFlowControl
-}) => {
-  const callHeaders = new Headers(step?.callHeaders);
-  const contentType = (callHeaders.get("content-type") ? callHeaders.get("content-type") : userHeaders?.get("Content-Type") ? userHeaders.get("Content-Type") : void 0) ?? DEFAULT_CONTENT_TYPE;
-  const baseHeaders = {
-    [WORKFLOW_INIT_HEADER]: initHeaderValue,
-    [WORKFLOW_ID_HEADER]: workflowRunId,
-    [WORKFLOW_URL_HEADER]: workflowUrl,
-    [WORKFLOW_FEATURE_HEADER]: "LazyFetch,InitialBody",
-    [WORKFLOW_PROTOCOL_VERSION_HEADER]: WORKFLOW_PROTOCOL_VERSION,
-    "content-type": contentType,
-    ...telemetry ? getTelemetryHeaders(telemetry) : {}
-  };
-  if (invokeCount !== void 0 && !step?.callUrl) {
-    baseHeaders[`Upstash-Forward-${WORKFLOW_INVOKE_COUNT_HEADER}`] = invokeCount.toString();
-  }
-  if (!step?.callUrl) {
-    baseHeaders[`Upstash-Forward-${WORKFLOW_PROTOCOL_VERSION_HEADER}`] = WORKFLOW_PROTOCOL_VERSION;
-  }
-  if (callTimeout) {
-    baseHeaders[`Upstash-Timeout`] = callTimeout.toString();
-  }
-  if (failureUrl) {
-    baseHeaders[`Upstash-Failure-Callback-Forward-${WORKFLOW_FAILURE_HEADER}`] = "true";
-    baseHeaders[`Upstash-Failure-Callback-Forward-Upstash-Workflow-Failure-Callback`] = "true";
-    baseHeaders["Upstash-Failure-Callback-Workflow-Runid"] = workflowRunId;
-    baseHeaders["Upstash-Failure-Callback-Workflow-Init"] = "false";
-    baseHeaders["Upstash-Failure-Callback-Workflow-Url"] = workflowUrl;
-    baseHeaders["Upstash-Failure-Callback-Workflow-Calltype"] = "failureCall";
-    if (retries !== void 0) {
-      baseHeaders["Upstash-Failure-Callback-Retries"] = retries.toString();
-    }
-    if (flowControl) {
-      const { flowControlKey, flowControlValue } = prepareFlowControl(flowControl);
-      baseHeaders["Upstash-Failure-Callback-Flow-Control-Key"] = flowControlKey;
-      baseHeaders["Upstash-Failure-Callback-Flow-Control-Value"] = flowControlValue;
-    }
-    if (!step?.callUrl) {
-      baseHeaders["Upstash-Failure-Callback"] = failureUrl;
-    }
-  }
-  if (step?.callUrl) {
-    baseHeaders["Upstash-Retries"] = callRetries?.toString() ?? "0";
-    baseHeaders[WORKFLOW_FEATURE_HEADER] = "WF_NoDelete,InitialBody";
-    if (retries !== void 0) {
-      baseHeaders["Upstash-Callback-Retries"] = retries.toString();
-      baseHeaders["Upstash-Failure-Callback-Retries"] = retries.toString();
-    }
-    if (callFlowControl) {
-      const { flowControlKey, flowControlValue } = prepareFlowControl(callFlowControl);
-      baseHeaders["Upstash-Flow-Control-Key"] = flowControlKey;
-      baseHeaders["Upstash-Flow-Control-Value"] = flowControlValue;
-    }
-    if (flowControl) {
-      const { flowControlKey, flowControlValue } = prepareFlowControl(flowControl);
-      baseHeaders["Upstash-Callback-Flow-Control-Key"] = flowControlKey;
-      baseHeaders["Upstash-Callback-Flow-Control-Value"] = flowControlValue;
+  addInvokeCount() {
+    if (this.invokeCount === void 0 || this.invokeCount === 0) {
+      return;
     }
-  } else {
-    if (flowControl) {
-      const { flowControlKey, flowControlValue } = prepareFlowControl(flowControl);
-      baseHeaders["Upstash-Flow-Control-Key"] = flowControlKey;
-      baseHeaders["Upstash-Flow-Control-Value"] = flowControlValue;
+    const invokeCount = this.invokeCount.toString();
+    this.headers.workflowHeaders[`Forward-${WORKFLOW_INVOKE_COUNT_HEADER}`] = invokeCount;
+    if (this.workflowConfig.failureUrl) {
+      this.headers.failureHeaders[`Forward-${WORKFLOW_INVOKE_COUNT_HEADER}`] = invokeCount;
     }
-    if (retries !== void 0) {
-      baseHeaders["Upstash-Retries"] = retries.toString();
-      baseHeaders["Upstash-Failure-Callback-Retries"] = retries.toString();
+    if (this.stepInfo?.lazyStep instanceof LazyCallStep) {
+      this.headers.rawHeaders[`Upstash-Forward-${WORKFLOW_INVOKE_COUNT_HEADER}`] = invokeCount;
     }
   }
-  if (userHeaders) {
-    for (const header of userHeaders.keys()) {
-      if (step?.callHeaders) {
-        baseHeaders[`Upstash-Callback-Forward-${header}`] = userHeaders.get(header);
-      } else {
-        baseHeaders[`Upstash-Forward-${header}`] = userHeaders.get(header);
-      }
-      baseHeaders[`Upstash-Failure-Callback-Forward-${header}`] = userHeaders.get(header);
+  addRetries() {
+    if (this.workflowConfig.retries === void 0 || this.workflowConfig.retries === DEFAULT_RETRIES) {
+      return;
+    }
+    const retries = this.workflowConfig.retries.toString();
+    this.headers.workflowHeaders["Retries"] = retries;
+    if (this.workflowConfig.failureUrl) {
+      this.headers.failureHeaders["Retries"] = retries;
     }
   }
-  if (step?.callHeaders) {
-    const forwardedHeaders = Object.fromEntries(
-      Object.entries(step.callHeaders).map(([header, value]) => [
-        `Upstash-Forward-${header}`,
-        value
-      ])
+  addFlowControl() {
+    if (!this.workflowConfig.flowControl) {
+      return;
+    }
+    const { flowControlKey, flowControlValue } = prepareFlowControl(
+      this.workflowConfig.flowControl
     );
-    return {
-      headers: {
-        ...baseHeaders,
-        ...forwardedHeaders,
-        "Upstash-Callback": workflowUrl,
-        "Upstash-Callback-Workflow-RunId": workflowRunId,
-        "Upstash-Callback-Workflow-CallType": "fromCallback",
-        "Upstash-Callback-Workflow-Init": "false",
-        "Upstash-Callback-Workflow-Url": workflowUrl,
-        "Upstash-Callback-Feature-Set": "LazyFetch,InitialBody",
-        "Upstash-Callback-Forward-Upstash-Workflow-Callback": "true",
-        "Upstash-Callback-Forward-Upstash-Workflow-StepId": step.stepId.toString(),
-        "Upstash-Callback-Forward-Upstash-Workflow-StepName": step.stepName,
-        "Upstash-Callback-Forward-Upstash-Workflow-StepType": step.stepType,
-        "Upstash-Callback-Forward-Upstash-Workflow-Concurrent": step.concurrent.toString(),
-        "Upstash-Callback-Forward-Upstash-Workflow-ContentType": contentType,
-        [`Upstash-Callback-Forward-${WORKFLOW_INVOKE_COUNT_HEADER}`]: (invokeCount ?? 0).toString(),
-        "Upstash-Workflow-CallType": "toCallback"
+    this.headers.workflowHeaders["Flow-Control-Key"] = flowControlKey;
+    this.headers.workflowHeaders["Flow-Control-Value"] = flowControlValue;
+    if (this.workflowConfig.failureUrl) {
+      this.headers.failureHeaders["Flow-Control-Key"] = flowControlKey;
+      this.headers.failureHeaders["Flow-Control-Value"] = flowControlValue;
+    }
+  }
+  addUserHeaders() {
+    for (const [key, value] of this.userHeaders.entries()) {
+      const forwardKey = `Forward-${key}`;
+      this.headers.workflowHeaders[forwardKey] = value;
+      if (this.workflowConfig.failureUrl) {
+        this.headers.failureHeaders[forwardKey] = value;
       }
-    };
+    }
+  }
+  addFailureUrl() {
+    if (!this.workflowConfig.failureUrl) {
+      return;
+    }
+    this.headers.workflowHeaders["Failure-Callback"] = this.workflowConfig.failureUrl;
+    this.headers.failureHeaders[`Forward-${WORKFLOW_FAILURE_HEADER}`] = "true";
+    this.headers.failureHeaders[`Forward-Upstash-Workflow-Failure-Callback`] = "true";
+    this.headers.failureHeaders["Workflow-Runid"] = this.workflowConfig.workflowRunId;
+    this.headers.failureHeaders["Workflow-Init"] = "false";
+    this.headers.failureHeaders["Workflow-Url"] = this.workflowConfig.workflowUrl;
+    this.headers.failureHeaders["Workflow-Calltype"] = "failureCall";
+    this.headers.failureHeaders["Feature-Set"] = "LazyFetch,InitialBody";
+    if (this.workflowConfig.retries !== void 0 && this.workflowConfig.retries !== DEFAULT_RETRIES) {
+      this.headers.failureHeaders["Retries"] = this.workflowConfig.retries.toString();
+    }
+  }
+  addContentType() {
+    if (this.workflowConfig.useJSONContent) {
+      this.headers.rawHeaders["content-type"] = "application/json";
+      return "application/json";
+    }
+    const callHeaders = new Headers(
+      this.stepInfo?.lazyStep instanceof LazyCallStep ? this.stepInfo.lazyStep.headers : {}
+    );
+    const contentType = (callHeaders.get("content-type") ? callHeaders.get("content-type") : this.userHeaders?.get("Content-Type") ? this.userHeaders.get("Content-Type") : void 0) ?? DEFAULT_CONTENT_TYPE;
+    this.headers.rawHeaders["content-type"] = contentType;
+    return contentType;
   }
-  if (step?.waitEventId) {
+  prefixHeaders(contentType) {
+    const { rawHeaders, workflowHeaders, failureHeaders } = this.headers;
+    const isCall = this.stepInfo?.lazyStep.stepType === "Call";
     return {
       headers: {
-        ...baseHeaders,
-        "Upstash-Workflow-CallType": "step"
+        ...rawHeaders,
+        ...addPrefixToHeaders(workflowHeaders, isCall ? "Upstash-Callback-" : "Upstash-"),
+        ...addPrefixToHeaders(failureHeaders, "Upstash-Failure-Callback-"),
+        ...isCall ? addPrefixToHeaders(failureHeaders, "Upstash-Callback-Failure-Callback-") : {}
       },
-      timeoutHeaders: {
-        // to include user headers:
-        ...Object.fromEntries(
-          Object.entries(baseHeaders).map(([header, value]) => [header, [value]])
-        ),
-        // to include telemetry headers:
-        ...telemetry ? Object.fromEntries(
-          Object.entries(getTelemetryHeaders(telemetry)).map(([header, value]) => [
-            header,
-            [value]
-          ])
-        ) : {},
-        // note: using WORKFLOW_ID_HEADER doesn't work, because Runid -> RunId:
-        "Upstash-Workflow-Runid": [workflowRunId],
-        [WORKFLOW_INIT_HEADER]: ["false"],
-        [WORKFLOW_URL_HEADER]: [workflowUrl],
-        "Upstash-Workflow-CallType": ["step"]
-      }
+      contentType
     };
   }
-  return { headers: baseHeaders };
 };
-var verifyRequest = async (body, signature, verifier) => {
-  if (!verifier) {
-    return;
-  }
-  try {
-    if (!signature) {
-      throw new Error("`Upstash-Signature` header is not passed.");
-    }
-    const isValid = await verifier.verify({
-      body,
-      signature
-    });
-    if (!isValid) {
-      throw new Error("Signature in `Upstash-Signature` header is not valid");
-    }
-  } catch (error) {
-    throw new WorkflowError(
-      `Failed to verify that the Workflow request comes from QStash: ${error}
-
-If signature is missing, trigger the workflow endpoint by publishing your request to QStash instead of calling it directly.
-
-If you want to disable QStash Verification, you should clear env variables QSTASH_CURRENT_SIGNING_KEY and QSTASH_NEXT_SIGNING_KEY`
-    );
+function addPrefixToHeaders(headers, prefix) {
+  const prefixedHeaders = {};
+  for (const [key, value] of Object.entries(headers)) {
+    prefixedHeaders[`${prefix}${key}`] = value;
   }
-};
+  return prefixedHeaders;
+}
 var prepareFlowControl = (flowControl) => {
   const parallelism = flowControl.parallelism?.toString();
-  const rate = flowControl.ratePerSecond?.toString();
+  const rate = (flowControl.rate ?? flowControl.ratePerSecond)?.toString();
+  const period = typeof flowControl.period === "number" ? `${flowControl.period}s` : flowControl.period;
   const controlValue = [
     parallelism ? `parallelism=${parallelism}` : void 0,
-    rate ? `rate=${rate}` : void 0
+    rate ? `rate=${rate}` : void 0,
+    period ? `period=${period}` : void 0
   ].filter(Boolean);
   if (controlValue.length === 0) {
-    throw new import_qstash3.QstashError("Provide at least one of parallelism or ratePerSecond for flowControl");
+    throw new import_qstash4.QstashError("Provide at least one of parallelism or ratePerSecond for flowControl");
   }
   return {
     flowControlKey: flowControl.key,
     flowControlValue: controlValue.join(", ")
   };
 };
+var getHeaders = (params) => {
+  const workflowHeaders = new WorkflowHeaders(params);
+  return workflowHeaders.getHeaders();
+};
 
-// src/context/auto-executor.ts
-var import_qstash4 = require("@upstash/qstash");
-
-// src/serve/serve-many.ts
-var invokeWorkflow = async ({
-  settings,
-  invokeStep,
+// src/qstash/submit-steps.ts
+var submitParallelSteps = async ({
   context,
+  steps,
+  initialStepCount,
   invokeCount,
-  telemetry
+  telemetry,
+  debug
 }) => {
-  const {
-    body,
-    workflow,
-    headers = {},
-    workflowRunId = getWorkflowRunId(),
-    retries,
-    flowControl
-  } = settings;
-  const { workflowId } = workflow;
-  const {
-    retries: workflowRetries,
-    failureFunction,
-    failureUrl,
-    useJSONContent,
-    flowControl: workflowFlowControl
-  } = workflow.options;
-  if (!workflowId) {
-    throw new WorkflowError("You can only invoke workflow which has a workflowId");
-  }
-  const { headers: invokerHeaders } = getHeaders({
-    initHeaderValue: "false",
-    workflowRunId: context.workflowRunId,
-    workflowUrl: context.url,
-    userHeaders: context.headers,
-    failureUrl: context.failureUrl,
-    retries: context.retries,
-    telemetry,
+  const planSteps = steps.map(
+    (step, index) => step.getPlanStep(steps.length, initialStepCount + index)
+  );
+  await debug?.log("SUBMIT", "SUBMIT_STEP", {
+    length: planSteps.length,
+    steps: planSteps
+  });
+  const result = await context.qstashClient.batch(
+    planSteps.map((planStep) => {
+      const { headers } = getHeaders({
+        initHeaderValue: "false",
+        workflowConfig: {
+          workflowRunId: context.workflowRunId,
+          workflowUrl: context.url,
+          failureUrl: context.failureUrl,
+          retries: context.retries,
+          flowControl: context.flowControl,
+          telemetry
+        },
+        userHeaders: context.headers,
+        invokeCount
+      });
+      return {
+        headers,
+        method: "POST",
+        url: context.url,
+        body: JSON.stringify(planStep),
+        notBefore: planStep.sleepUntil,
+        delay: planStep.sleepFor
+      };
+    })
+  );
+  await debug?.log("INFO", "SUBMIT_STEP", {
+    messageIds: result.map((message) => {
+      return {
+        message: message.messageId
+      };
+    })
+  });
+  throw new WorkflowAbort(planSteps[0].stepName, planSteps[0]);
+};
+var submitSingleStep = async ({
+  context,
+  lazyStep,
+  stepId,
+  invokeCount,
+  concurrency,
+  telemetry,
+  debug
+}) => {
+  const resultStep = await lazyStep.getResultStep(concurrency, stepId);
+  await debug?.log("INFO", "RUN_SINGLE", {
+    fromRequest: false,
+    step: resultStep,
+    stepCount: stepId
+  });
+  const { headers } = lazyStep.getHeaders({
+    context,
+    step: resultStep,
     invokeCount,
-    flowControl: context.flowControl
+    telemetry
   });
-  invokerHeaders["Upstash-Workflow-Runid"] = context.workflowRunId;
-  const newUrl = context.url.replace(/[^/]+$/, workflowId);
-  const { headers: triggerHeaders } = getHeaders({
-    initHeaderValue: "true",
-    workflowRunId,
-    workflowUrl: newUrl,
-    userHeaders: new Headers(headers),
-    retries: retries ?? workflowRetries,
-    telemetry,
-    failureUrl: failureFunction ? newUrl : failureUrl,
-    invokeCount: invokeCount + 1,
-    flowControl: flowControl ?? workflowFlowControl
+  const body = lazyStep.getBody({
+    context,
+    step: resultStep,
+    headers,
+    invokeCount,
+    telemetry
   });
-  triggerHeaders["Upstash-Workflow-Invoke"] = "true";
-  if (useJSONContent) {
-    triggerHeaders["content-type"] = "application/json";
-  }
-  const request = {
-    body: JSON.stringify(body),
-    headers: Object.fromEntries(
-      Object.entries(invokerHeaders).map((pairs) => [pairs[0], [pairs[1]]])
-    ),
-    workflowRunId: context.workflowRunId,
-    workflowUrl: context.url,
-    step: invokeStep
-  };
-  await context.qstashClient.publish({
-    headers: triggerHeaders,
-    method: "POST",
-    body: JSON.stringify(request),
-    url: newUrl
+  await debug?.log("SUBMIT", "SUBMIT_STEP", {
+    length: 1,
+    steps: [resultStep]
+  });
+  const submitResult = await lazyStep.submitStep({
+    context,
+    body,
+    headers,
+    isParallel: concurrency !== NO_CONCURRENCY,
+    invokeCount,
+    step: resultStep,
+    telemetry
+  });
+  await debug?.log("INFO", "SUBMIT_STEP", {
+    messageIds: submitResult.map((message) => {
+      return {
+        message: message.messageId
+      };
+    })
   });
+  return resultStep;
 };
 
 // src/context/auto-executor.ts
@@ -1554,14 +1869,16 @@ var AutoExecutor = class _AutoExecutor {
       });
       return lazyStep.parseOut(step.out);
     }
-    const resultStep = await lazyStep.getResultStep(NO_CONCURRENCY, this.stepCount);
-    await this.debug?.log("INFO", "RUN_SINGLE", {
-      fromRequest: false,
-      step: resultStep,
-      stepCount: this.stepCount
+    const resultStep = await submitSingleStep({
+      context: this.context,
+      lazyStep,
+      stepId: this.stepCount,
+      invokeCount: this.invokeCount,
+      concurrency: 1,
+      telemetry: this.telemetry,
+      debug: this.debug
     });
-    await this.submitStepsToQStash([resultStep], [lazyStep]);
-    return resultStep.out;
+    throw new WorkflowAbort(lazyStep.stepName, resultStep);
   }
   /**
    * Runs steps in parallel.
@@ -1589,10 +1906,14 @@ var AutoExecutor = class _AutoExecutor {
     });
     switch (parallelCallState) {
       case "first": {
-        const planSteps = parallelSteps.map(
-          (parallelStep, index) => parallelStep.getPlanStep(parallelSteps.length, initialStepCount + index)
-        );
-        await this.submitStepsToQStash(planSteps, parallelSteps);
+        await submitParallelSteps({
+          context: this.context,
+          steps: parallelSteps,
+          initialStepCount,
+          invokeCount: this.invokeCount,
+          telemetry: this.telemetry,
+          debug: this.debug
+        });
         break;
       }
       case "partial": {
@@ -1606,13 +1927,18 @@ var AutoExecutor = class _AutoExecutor {
         validateStep(parallelSteps[stepIndex], planStep);
         try {
           const parallelStep = parallelSteps[stepIndex];
-          const resultStep = await parallelStep.getResultStep(
-            parallelSteps.length,
-            planStep.targetStep
-          );
-          await this.submitStepsToQStash([resultStep], [parallelStep]);
+          const resultStep = await submitSingleStep({
+            context: this.context,
+            lazyStep: parallelStep,
+            stepId: planStep.targetStep,
+            invokeCount: this.invokeCount,
+            concurrency: parallelSteps.length,
+            telemetry: this.telemetry,
+            debug: this.debug
+          });
+          throw new WorkflowAbort(parallelStep.stepName, resultStep);
         } catch (error) {
-          if (error instanceof WorkflowAbort || error instanceof import_qstash4.QstashError && error.status === 400) {
+          if (error instanceof WorkflowAbort || error instanceof import_qstash5.QstashError && error.status === 400) {
             throw error;
           }
           throw new WorkflowError(
@@ -1668,128 +1994,6 @@ var AutoExecutor = class _AutoExecutor {
       return "discard";
     }
   }
-  /**
-   * sends the steps to QStash as batch
-   *
-   * @param steps steps to send
-   */
-  async submitStepsToQStash(steps, lazySteps) {
-    if (steps.length === 0) {
-      throw new WorkflowError(
-        `Unable to submit steps to QStash. Provided list is empty. Current step: ${this.stepCount}`
-      );
-    }
-    await this.debug?.log("SUBMIT", "SUBMIT_STEP", {
-      length: steps.length,
-      steps
-    });
-    if (steps[0].waitEventId && steps.length === 1) {
-      const waitStep = steps[0];
-      const { headers, timeoutHeaders } = getHeaders({
-        initHeaderValue: "false",
-        workflowRunId: this.context.workflowRunId,
-        workflowUrl: this.context.url,
-        userHeaders: this.context.headers,
-        step: waitStep,
-        failureUrl: this.context.failureUrl,
-        retries: this.context.retries,
-        telemetry: this.telemetry,
-        invokeCount: this.invokeCount,
-        flowControl: this.context.flowControl
-      });
-      const waitBody = {
-        url: this.context.url,
-        timeout: waitStep.timeout,
-        timeoutBody: void 0,
-        timeoutUrl: this.context.url,
-        timeoutHeaders,
-        step: {
-          stepId: waitStep.stepId,
-          stepType: "Wait",
-          stepName: waitStep.stepName,
-          concurrent: waitStep.concurrent,
-          targetStep: waitStep.targetStep
-        }
-      };
-      await this.context.qstashClient.http.request({
-        path: ["v2", "wait", waitStep.waitEventId],
-        body: JSON.stringify(waitBody),
-        headers,
-        method: "POST",
-        parseResponseAsJson: false
-      });
-      throw new WorkflowAbort(waitStep.stepName, waitStep);
-    }
-    if (steps.length === 1 && lazySteps[0] instanceof LazyInvokeStep) {
-      const invokeStep = steps[0];
-      const lazyInvokeStep = lazySteps[0];
-      await invokeWorkflow({
-        settings: lazyInvokeStep.params,
-        invokeStep,
-        context: this.context,
-        invokeCount: this.invokeCount,
-        telemetry: this.telemetry
-      });
-      throw new WorkflowAbort(invokeStep.stepName, invokeStep);
-    }
-    const result = await this.context.qstashClient.batch(
-      steps.map((singleStep, index) => {
-        const lazyStep = lazySteps[index];
-        const { headers } = getHeaders({
-          initHeaderValue: "false",
-          workflowRunId: this.context.workflowRunId,
-          workflowUrl: this.context.url,
-          userHeaders: this.context.headers,
-          step: singleStep,
-          failureUrl: this.context.failureUrl,
-          retries: this.context.retries,
-          callRetries: lazyStep instanceof LazyCallStep ? lazyStep.retries : void 0,
-          callTimeout: lazyStep instanceof LazyCallStep ? lazyStep.timeout : void 0,
-          telemetry: this.telemetry,
-          invokeCount: this.invokeCount,
-          flowControl: this.context.flowControl,
-          callFlowControl: lazyStep instanceof LazyCallStep ? lazyStep.flowControl : void 0
-        });
-        const willWait = singleStep.concurrent === NO_CONCURRENCY || singleStep.stepId === 0;
-        singleStep.out = JSON.stringify(singleStep.out);
-        return singleStep.callUrl && lazyStep instanceof LazyCallStep ? (
-          // if the step is a third party call, we call the third party
-          // url (singleStep.callUrl) and pass information about the workflow
-          // in the headers (handled in getHeaders). QStash makes the request
-          // to callUrl and returns the result to Workflow endpoint.
-          // handleThirdPartyCallResult method sends the result of the third
-          // party call to QStash.
-          {
-            headers,
-            method: singleStep.callMethod,
-            body: JSON.stringify(singleStep.callBody),
-            url: singleStep.callUrl
-          }
-        ) : (
-          // if the step is not a third party call, we use workflow
-          // endpoint (context.url) as URL when calling QStash. QStash
-          // calls us back with the updated steps list.
-          {
-            headers,
-            method: "POST",
-            body: JSON.stringify(singleStep),
-            url: this.context.url,
-            notBefore: willWait ? singleStep.sleepUntil : void 0,
-            delay: willWait ? singleStep.sleepFor : void 0
-          }
-        );
-      })
-    );
-    const _result = result;
-    await this.debug?.log("INFO", "SUBMIT_STEP", {
-      messageIds: _result.map((message) => {
-        return {
-          message: message.messageId
-        };
-      })
-    });
-    throw new WorkflowAbort(steps[0].stepName, steps[0]);
-  }
   /**
    * Get the promise by executing the lazt steps list. If there is a single
    * step, we call `runSingle`. Otherwise `runParallel` is called.
@@ -1863,7 +2067,7 @@ var sortSteps = (steps) => {
 };
 
 // src/context/api/anthropic.ts
-var import_qstash5 = require("@upstash/qstash");
+var import_qstash6 = require("@upstash/qstash");
 
 // src/context/provider.ts
 var getProviderInfo = (api) => {
@@ -1927,7 +2131,7 @@ var AnthropicAPI = class extends BaseWorkflowApi {
     return await this.callApi(stepName, {
       api: {
         name: "llm",
-        provider: (0, import_qstash5.anthropic)({ token })
+        provider: (0, import_qstash6.anthropic)({ token })
       },
       ...parameters
     });
@@ -1935,12 +2139,12 @@ var AnthropicAPI = class extends BaseWorkflowApi {
 };
 
 // src/context/api/openai.ts
-var import_qstash6 = require("@upstash/qstash");
+var import_qstash7 = require("@upstash/qstash");
 var OpenAIAPI = class extends BaseWorkflowApi {
   async call(stepName, settings) {
     const { token, organization, operation, baseURL, ...parameters } = settings;
     const useOpenAI = baseURL === void 0;
-    const provider = useOpenAI ? (0, import_qstash6.openai)({ token, organization }) : (0, import_qstash6.custom)({ baseUrl: baseURL, token });
+    const provider = useOpenAI ? (0, import_qstash7.openai)({ token, organization }) : (0, import_qstash7.custom)({ baseUrl: baseURL, token });
     return await this.callApi(stepName, {
       api: {
         name: "llm",
@@ -1952,14 +2156,14 @@ var OpenAIAPI = class extends BaseWorkflowApi {
 };
 
 // src/context/api/resend.ts
-var import_qstash7 = require("@upstash/qstash");
+var import_qstash8 = require("@upstash/qstash");
 var ResendAPI = class extends BaseWorkflowApi {
   async call(stepName, settings) {
     const { token, batch = false, ...parameters } = settings;
     return await this.callApi(stepName, {
       api: {
         name: "email",
-        provider: (0, import_qstash7.resend)({ token, batch })
+        provider: (0, import_qstash8.resend)({ token, batch })
       },
       ...parameters
     });
@@ -1986,28 +2190,11 @@ var WorkflowApi = class extends BaseWorkflowApi {
 };
 
 // src/agents/index.ts
-var import_openai3 = require("@ai-sdk/openai");
-
-// src/agents/adapters.ts
 var import_openai2 = require("@ai-sdk/openai");
-var import_ai = require("ai");
-
-// src/agents/constants.ts
-var AGENT_NAME_HEADER = "upstash-agent-name";
-var MANAGER_AGENT_PROMPT = `You are an agent orchestrating other AI Agents.
-
-These other agents have tools available to them.
-
-Given a prompt, utilize these agents to address requests.
-
-Don't always call all the agents provided to you at the same time. You can call one and use it's response to call another.
-
-Avoid calling the same agent twice in one turn. Instead, prefer to call it once but provide everything
-you need from that agent.
-`;
 
 // src/agents/adapters.ts
-var fetchWithContextCall = async (context, ...params) => {
+var import_ai = require("ai");
+var fetchWithContextCall = async (context, agentCallParams, ...params) => {
   const [input, init] = params;
   try {
     const headers = init?.headers ? Object.fromEntries(new Headers(init.headers).entries()) : {};
@@ -2018,7 +2205,10 @@ var fetchWithContextCall = async (context, ...params) => {
       url: input.toString(),
       method: init?.method,
       headers,
-      body
+      body,
+      timeout: agentCallParams?.timeout,
+      retries: agentCallParams?.retries,
+      flowControl: agentCallParams?.flowControl
     });
     const responseHeaders = new Headers(
       Object.entries(responseInfo.header).reduce(
@@ -2045,10 +2235,11 @@ var fetchWithContextCall = async (context, ...params) => {
 var createWorkflowModel = ({
   context,
   provider,
-  providerParams
+  providerParams,
+  agentCallParams
 }) => {
   return provider({
-    fetch: (...params) => fetchWithContextCall(context, ...params),
+    fetch: (...params) => fetchWithContextCall(context, agentCallParams, ...params),
     ...providerParams
   });
 };
@@ -2319,17 +2510,26 @@ var WorkflowAgents = class {
    */
   openai(...params) {
     const [model, settings] = params;
-    const { baseURL, apiKey, ...otherSettings } = settings ?? {};
+    const { baseURL, apiKey, callSettings, ...otherSettings } = settings ?? {};
     const openaiModel = this.AISDKModel({
       context: this.context,
-      provider: import_openai3.createOpenAI,
-      providerParams: { baseURL, apiKey, compatibility: "strict" }
+      provider: import_openai2.createOpenAI,
+      providerParams: { baseURL, apiKey, compatibility: "strict" },
+      agentCallParams: callSettings
     });
     return openaiModel(model, otherSettings);
   }
   AISDKModel = createWorkflowModel;
 };
 
+// src/serve/serve-many.ts
+var getNewUrlFromWorkflowId = (url, workflowId) => {
+  if (!workflowId) {
+    throw new WorkflowError("You can only call workflow which has a workflowId");
+  }
+  return url.replace(/[^/]+$/, workflowId);
+};
+
 // src/context/context.ts
 var WorkflowContext = class {
   executor;
@@ -2551,60 +2751,42 @@ var WorkflowContext = class {
     }
     await this.addStep(new LazySleepUntilStep(stepName, time));
   }
-  /**
-   * Makes a third party call through QStash in order to make a
-   * network call without consuming any runtime.
-   *
-   * ```ts
-   * const { status, body } = await context.call<string>(
-   *   "post call step",
-   *   {
-   *     url: "https://www.some-endpoint.com/api",
-   *     method: "POST",
-   *     body: "my-payload"
-   *   }
-   * );
-   * ```
-   *
-   * tries to parse the result of the request as JSON. If it's
-   * not a JSON which can be parsed, simply returns the response
-   * body as it is.
-   *
-   * @param stepName
-   * @param url url to call
-   * @param method call method. "GET" by default.
-   * @param body call body
-   * @param headers call headers
-   * @param retries number of call retries. 0 by default
-   * @param timeout max duration to wait for the endpoint to respond. in seconds.
-   * @returns call result as {
-   *     status: number;
-   *     body: unknown;
-   *     header: Record<string, string[]>
-   *   }
-   */
   async call(stepName, settings) {
-    const {
-      url,
-      method = "GET",
-      body: requestBody,
-      headers = {},
-      retries = 0,
-      timeout,
-      flowControl
-    } = settings;
-    return await this.addStep(
-      new LazyCallStep(
+    let callStep;
+    if ("workflow" in settings) {
+      const url = getNewUrlFromWorkflowId(this.url, settings.workflow.workflowId);
+      callStep = new LazyCallStep(
+        stepName,
+        url,
+        "POST",
+        settings.body,
+        settings.headers || {},
+        settings.retries || 0,
+        settings.timeout,
+        settings.flowControl ?? settings.workflow.options.flowControl
+      );
+    } else {
+      const {
+        url,
+        method = "GET",
+        body,
+        headers = {},
+        retries = 0,
+        timeout,
+        flowControl
+      } = settings;
+      callStep = new LazyCallStep(
         stepName,
         url,
         method,
-        requestBody,
+        body,
         headers,
         retries,
         timeout,
         flowControl
-      )
-    );
+      );
+    }
+    return await this.addStep(callStep);
   }
   /**
    * Pauses workflow execution until a specific event occurs or a timeout is reached.
@@ -2752,7 +2934,7 @@ var WorkflowLogger = class _WorkflowLogger {
 };
 
 // src/serve/authorization.ts
-var import_qstash8 = require("@upstash/qstash");
+var import_qstash9 = require("@upstash/qstash");
 var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowContext {
   static disabledMessage = "disabled-qstash-worklfow-run";
   disabled = true;
@@ -2784,7 +2966,7 @@ var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowCon
    */
   static async tryAuthentication(routeFunction, context) {
     const disabledContext = new _DisabledWorkflowContext({
-      qstashClient: new import_qstash8.Client({
+      qstashClient: new import_qstash9.Client({
         baseUrl: "disabled-client",
         token: "disabled-client"
       }),
@@ -2998,15 +3180,15 @@ var handleFailure = async (request, requestPayload, qstashClient, initialPayload
 };
 
 // src/serve/options.ts
-var import_qstash9 = require("@upstash/qstash");
 var import_qstash10 = require("@upstash/qstash");
+var import_qstash11 = require("@upstash/qstash");
 var processOptions = (options) => {
   const environment = options?.env ?? (typeof process === "undefined" ? {} : process.env);
   const receiverEnvironmentVariablesSet = Boolean(
     environment.QSTASH_CURRENT_SIGNING_KEY && environment.QSTASH_NEXT_SIGNING_KEY
   );
   return {
-    qstashClient: new import_qstash10.Client({
+    qstashClient: new import_qstash11.Client({
       baseUrl: environment.QSTASH_URL,
       token: environment.QSTASH_TOKEN
     }),
@@ -3041,7 +3223,7 @@ var processOptions = (options) => {
         throw error;
       }
     },
-    receiver: receiverEnvironmentVariablesSet ? new import_qstash9.Receiver({
+    receiver: receiverEnvironmentVariablesSet ? new import_qstash10.Receiver({
       currentSigningKey: environment.QSTASH_CURRENT_SIGNING_KEY,
       nextSigningKey: environment.QSTASH_NEXT_SIGNING_KEY
     }) : void 0,
@@ -3261,7 +3443,7 @@ var serve = (routeFunction, options) => {
 };
 
 // src/client/index.ts
-var import_qstash11 = require("@upstash/qstash");
+var import_qstash12 = require("@upstash/qstash");
 var Client4 = class {
   client;
   constructor(clientConfig) {
@@ -3270,7 +3452,7 @@ var Client4 = class {
         "QStash token is required for Upstash Workflow!\n\nTo fix this:\n1. Get your token from the Upstash Console (https://console.upstash.com/qstash)\n2. Initialize the workflow client with:\n\n   const client = new Client({\n     token: '<YOUR_QSTASH_TOKEN>'\n   });"
       );
     }
-    this.client = new import_qstash11.Client(clientConfig);
+    this.client = new import_qstash12.Client(clientConfig);
   }
   /**
    * Cancel an ongoing workflow
@@ -3388,63 +3570,39 @@ var Client4 = class {
   async getWaiters({ eventId }) {
     return await makeGetWaitersRequest(this.client.http, eventId);
   }
-  /**
-   * Trigger new workflow run and returns the workflow run id
-   *
-   * ```ts
-   * const { workflowRunId } = await client.trigger({
-   *   url: "https://workflow-endpoint.com",
-   *   body: "hello there!",         // Optional body
-   *   headers: { ... },             // Optional headers
-   *   workflowRunId: "my-workflow", // Optional workflow run ID
-   *   retries: 3                    // Optional retries for the initial request
-   * });
-   *
-   * console.log(workflowRunId)
-   * // wfr_my-workflow
-   * ```
-   *
-   * @param url URL of the workflow
-   * @param body body to start the workflow with
-   * @param headers headers to use in the request
-   * @param workflowRunId optional workflow run id to use. mind that
-   *   you should pass different workflow run ids for different runs.
-   *   The final workflowRunId will be `wfr_${workflowRunId}`, in
-   *   other words: the workflow run id you pass will be prefixed
-   *   with `wfr_`.
-   * @param retries retry to use in the initial request. in the rest of
-   *   the workflow, `retries` option of the `serve` will be used.
-   * @returns workflow run id
-   */
-  async trigger({
-    url,
-    body,
-    headers,
-    workflowRunId,
-    retries,
-    flowControl
-  }) {
-    const finalWorkflowRunId = getWorkflowRunId(workflowRunId);
-    const context = new WorkflowContext({
-      qstashClient: this.client,
-      // @ts-expect-error headers type mismatch
-      headers: new Headers(headers ?? {}),
-      initialPayload: body,
-      steps: [],
-      url,
-      workflowRunId: finalWorkflowRunId,
-      retries,
-      telemetry: void 0,
-      // can't know workflow telemetry here
-      flowControl
-    });
-    const result = await triggerFirstInvocation({
-      workflowContext: context,
-      telemetry: void 0
-      // can't know workflow telemetry here
+  async trigger(params) {
+    const isBatchInput = Array.isArray(params);
+    const options = isBatchInput ? params : [params];
+    const invocations = options.map((option) => {
+      const failureUrl = option.useFailureFunction ? option.url : option.failureUrl;
+      const finalWorkflowRunId = getWorkflowRunId(option.workflowRunId);
+      const context = new WorkflowContext({
+        qstashClient: this.client,
+        // @ts-expect-error headers type mismatch
+        headers: new Headers(option.headers ?? {}),
+        initialPayload: option.body,
+        steps: [],
+        url: option.url,
+        workflowRunId: finalWorkflowRunId,
+        retries: option.retries,
+        telemetry: void 0,
+        // can't know workflow telemetry here
+        flowControl: option.flowControl,
+        failureUrl
+      });
+      return {
+        workflowContext: context,
+        telemetry: void 0,
+        // can't know workflow telemetry here
+        delay: option.delay
+      };
     });
+    const result = await triggerFirstInvocation(invocations);
+    const workflowRunIds = invocations.map(
+      (invocation) => invocation.workflowContext.workflowRunId
+    );
     if (result.isOk()) {
-      return { workflowRunId: finalWorkflowRunId };
+      return isBatchInput ? workflowRunIds.map((id) => ({ workflowRunId: id })) : { workflowRunId: workflowRunIds[0] };
     } else {
       throw result.error;
     }