@upstash/workflow 0.2.8-rc-invoke → 0.2.9

package/{chunk-IWAW7GIG.mjs → chunk-IPXJZU3K.mjs}

@@ -36,6 +36,7 @@ var WORKFLOW_INIT_HEADER = "Upstash-Workflow-Init";
 var WORKFLOW_URL_HEADER = "Upstash-Workflow-Url";
 var WORKFLOW_FAILURE_HEADER = "Upstash-Workflow-Is-Failure";
 var WORKFLOW_FEATURE_HEADER = "Upstash-Feature-Set";
+var WORKFLOW_INVOKE_COUNT_HEADER = "Upstash-Workflow-Invoke-Count";
 var WORKFLOW_PROTOCOL_VERSION = "1";
 var WORKFLOW_PROTOCOL_VERSION_HEADER = "Upstash-Workflow-Sdk-Version";
 var DEFAULT_CONTENT_TYPE = "application/json";
@@ -100,66 +101,6 @@ var StepTypes = [
   "Invoke"
 ];
 
-// src/client/utils.ts
-import { QstashError as QstashError2 } from "@upstash/qstash";
-var makeNotifyRequest = async (requester, eventId, eventData) => {
-  const result = await requester.request({
-    path: ["v2", "notify", eventId],
-    method: "POST",
-    body: typeof eventData === "string" ? eventData : JSON.stringify(eventData)
-  });
-  return result;
-};
-var makeGetWaitersRequest = async (requester, eventId) => {
-  const result = await requester.request({
-    path: ["v2", "waiters", eventId],
-    method: "GET"
-  });
-  return result;
-};
-var makeCancelRequest = async (requester, workflowRunId) => {
-  await requester.request({
-    path: ["v2", "workflows", "runs", `${workflowRunId}?cancel=true`],
-    method: "DELETE",
-    parseResponseAsJson: false
-  });
-  return true;
-};
-var getSteps = async (requester, workflowRunId, messageId, debug) => {
-  try {
-    const steps = await requester.request({
-      path: ["v2", "workflows", "runs", workflowRunId],
-      parseResponseAsJson: true
-    });
-    if (!messageId) {
-      await debug?.log("INFO", "ENDPOINT_START", {
-        message: `Pulled ${steps.length} steps from QStashand returned them without filtering with messageId.`
-      });
-      return { steps, workflowRunEnded: false };
-    } else {
-      const index = steps.findIndex((item) => item.messageId === messageId);
-      if (index === -1) {
-        return { steps: [], workflowRunEnded: false };
-      }
-      const filteredSteps = steps.slice(0, index + 1);
-      await debug?.log("INFO", "ENDPOINT_START", {
-        message: `Pulled ${steps.length} steps from QStash and filtered them to ${filteredSteps.length} using messageId.`
-      });
-      return { steps: filteredSteps, workflowRunEnded: false };
-    }
-  } catch (error) {
-    if (error instanceof QstashError2 && error.status === 404) {
-      await debug?.log("WARN", "ENDPOINT_START", {
-        message: "Couldn't fetch workflow run steps. This can happen if the workflow run succesfully ends before some callback is executed.",
-        error
-      });
-      return { steps: void 0, workflowRunEnded: true };
-    } else {
-      throw error;
-    }
-  }
-};
-
 // src/utils.ts
 var NANOID_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
 var NANOID_LENGTH = 21;
@@ -185,339 +126,123 @@ function decodeBase64(base64) {
   }
 }
 
-// src/context/steps.ts
-var BaseLazyStep = class {
-  stepName;
-  // will be set in the subclasses
-  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 LazyFunctionStep = class extends BaseLazyStep {
-  stepFunction;
-  stepType = "Run";
-  constructor(stepName, stepFunction) {
-    super(stepName);
-    this.stepFunction = stepFunction;
+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);
+    });
   }
-  getPlanStep(concurrent, targetStep) {
-    return {
-      stepId: 0,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      concurrent,
-      targetStep
+  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);
+      });
     };
   }
-  async getResultStep(concurrent, stepId) {
-    let result = this.stepFunction();
-    if (result instanceof Promise) {
-      result = await result;
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
     }
-    return {
-      stepId,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      out: result,
-      concurrent
-    };
   }
-};
-var LazySleepStep = class extends BaseLazyStep {
-  sleep;
-  stepType = "SleepFor";
-  constructor(stepName, sleep) {
-    super(stepName);
-    this.sleep = sleep;
+  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,
-      sleepFor: this.sleep,
-      concurrent,
-      targetStep
-    };
+  function fulfill(value) {
+    resume("next", value);
   }
-  async getResultStep(concurrent, stepId) {
-    return await Promise.resolve({
-      stepId,
-      stepName: this.stepName,
-      stepType: this.stepType,
-      sleepFor: this.sleep,
-      concurrent
-    });
+  function reject(value) {
+    resume("throw", value);
   }
-};
-var LazySleepUntilStep = class extends BaseLazyStep {
-  sleepUntil;
-  stepType = "SleepUntil";
-  constructor(stepName, sleepUntil) {
-    super(stepName);
-    this.sleepUntil = sleepUntil;
+  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,
-      sleepUntil: this.sleepUntil,
-      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,
-      sleepUntil: this.sleepUntil,
-      concurrent
-    });
-  }
-};
-var LazyCallStep = class extends BaseLazyStep {
-  url;
-  method;
-  body;
-  headers;
-  retries;
-  timeout;
-  stepType = "Call";
-  constructor(stepName, url, method, body, headers, retries, timeout) {
-    super(stepName);
-    this.url = url;
-    this.method = method;
-    this.body = body;
-    this.headers = headers;
-    this.retries = retries;
-    this.timeout = timeout;
-  }
-  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
-    });
-  }
-};
-var LazyWaitForEventStep = class extends BaseLazyStep {
-  eventId;
-  timeout;
-  stepType = "Wait";
-  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
-    });
-  }
-};
-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
-      };
-    });
-  }
-};
-var LazyInvokeStep = class extends BaseLazyStep {
-  stepType = "Invoke";
-  params;
-  constructor(stepName, { workflow, body, headers = {}, workflowRunId, retries }) {
-    super(stepName);
-    this.params = {
-      workflow,
-      body,
-      headers,
-      workflowRunId: getWorkflowRunId(workflowRunId),
-      retries
-    };
-  }
-  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
-    });
-  }
-};
-
-// 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);
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
   }
 }
 var ResultAsync = class _ResultAsync {
@@ -818,29 +543,94 @@ var fromThrowable = Result.fromThrowable;
 
 // src/workflow-requests.ts
 import { QstashError as QstashError3 } from "@upstash/qstash";
-var triggerFirstInvocation = async ({
-  workflowContext,
-  useJSONContent,
-  telemetry,
-  debug
-}) => {
-  const { headers } = getHeaders({
-    initHeaderValue: "true",
-    workflowRunId: workflowContext.workflowRunId,
-    workflowUrl: workflowContext.url,
-    userHeaders: workflowContext.headers,
-    failureUrl: workflowContext.failureUrl,
-    retries: workflowContext.retries,
-    telemetry
+
+// src/client/utils.ts
+import { QstashError as QstashError2 } from "@upstash/qstash";
+var makeNotifyRequest = async (requester, eventId, eventData) => {
+  const result = await requester.request({
+    path: ["v2", "notify", eventId],
+    method: "POST",
+    body: typeof eventData === "string" ? eventData : JSON.stringify(eventData)
   });
-  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);
+  return result;
+};
+var makeGetWaitersRequest = async (requester, eventId) => {
+  const result = await requester.request({
+    path: ["v2", "waiters", eventId],
+    method: "GET"
+  });
+  return result;
+};
+var makeCancelRequest = async (requester, workflowRunId) => {
+  await requester.request({
+    path: ["v2", "workflows", "runs", `${workflowRunId}?cancel=true`],
+    method: "DELETE",
+    parseResponseAsJson: false
+  });
+  return true;
+};
+var getSteps = async (requester, workflowRunId, messageId, debug) => {
+  try {
+    const steps = await requester.request({
+      path: ["v2", "workflows", "runs", workflowRunId],
+      parseResponseAsJson: true
+    });
+    if (!messageId) {
+      await debug?.log("INFO", "ENDPOINT_START", {
+        message: `Pulled ${steps.length} steps from QStashand returned them without filtering with messageId.`
+      });
+      return { steps, workflowRunEnded: false };
+    } else {
+      const index = steps.findIndex((item) => item.messageId === messageId);
+      if (index === -1) {
+        return { steps: [], workflowRunEnded: false };
+      }
+      const filteredSteps = steps.slice(0, index + 1);
+      await debug?.log("INFO", "ENDPOINT_START", {
+        message: `Pulled ${steps.length} steps from QStash and filtered them to ${filteredSteps.length} using messageId.`
+      });
+      return { steps: filteredSteps, workflowRunEnded: false };
+    }
+  } catch (error) {
+    if (error instanceof QstashError2 && error.status === 404) {
+      await debug?.log("WARN", "ENDPOINT_START", {
+        message: "Couldn't fetch workflow run steps. This can happen if the workflow run succesfully ends before some callback is executed.",
+        error
+      });
+      return { steps: void 0, workflowRunEnded: true };
+    } else {
+      throw error;
+    }
+  }
+};
+
+// src/workflow-requests.ts
+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",
@@ -937,6 +727,7 @@ var handleThirdPartyCallResult = async ({
   failureUrl,
   retries,
   telemetry,
+  flowControl,
   debug
 }) => {
   try {
@@ -984,6 +775,7 @@ ${atob(callbackMessage.body ?? "")}`
       const stepType = request.headers.get("Upstash-Workflow-StepType");
       const concurrentString = request.headers.get("Upstash-Workflow-Concurrent");
       const contentType = request.headers.get("Upstash-Workflow-ContentType");
+      const invokeCount = request.headers.get(WORKFLOW_INVOKE_COUNT_HEADER);
       if (!(workflowRunId && stepIdString && stepName && StepTypes.includes(stepType) && concurrentString && contentType)) {
         throw new Error(
           `Missing info in callback message source header: ${JSON.stringify({
@@ -1004,7 +796,9 @@ ${atob(callbackMessage.body ?? "")}`
         userHeaders,
         failureUrl,
         retries,
-        telemetry
+        telemetry,
+        invokeCount: Number(invokeCount),
+        flowControl
       });
       const callResponse = {
         status: callbackMessage.status,
@@ -1060,7 +854,10 @@ var getHeaders = ({
   step,
   callRetries,
   callTimeout,
-  telemetry
+  telemetry,
+  invokeCount,
+  flowControl,
+  callFlowControl
 }) => {
   const contentType = (userHeaders ? userHeaders.get("Content-Type") : void 0) ?? DEFAULT_CONTENT_TYPE;
   const baseHeaders = {
@@ -1072,6 +869,9 @@ var getHeaders = ({
     "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;
   }
@@ -1080,13 +880,23 @@ var getHeaders = ({
   }
   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?.stepType === "Invoke") {
-    baseHeaders["upstash-workflow-invoke"] = "true";
-  }
   if (step?.callUrl) {
     baseHeaders["Upstash-Retries"] = callRetries?.toString() ?? "0";
     baseHeaders[WORKFLOW_FEATURE_HEADER] = "WF_NoDelete,InitialBody";
@@ -1094,9 +904,26 @@ var getHeaders = ({
       baseHeaders["Upstash-Callback-Retries"] = retries.toString();
       baseHeaders["Upstash-Failure-Callback-Retries"] = retries.toString();
     }
-  } else if (retries !== void 0) {
-    baseHeaders["Upstash-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;
+    }
+  } else {
+    if (flowControl) {
+      const { flowControlKey, flowControlValue } = prepareFlowControl(flowControl);
+      baseHeaders["Upstash-Flow-Control-Key"] = flowControlKey;
+      baseHeaders["Upstash-Flow-Control-Value"] = flowControlValue;
+    }
+    if (retries !== void 0) {
+      baseHeaders["Upstash-Retries"] = retries.toString();
+      baseHeaders["Upstash-Failure-Callback-Retries"] = retries.toString();
+    }
   }
   if (userHeaders) {
     for (const header of userHeaders.keys()) {
@@ -1116,76 +943,575 @@ var getHeaders = ({
       ])
     );
     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-Workflow-CallType": "toCallback"
-      }
+      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"
+      }
+    };
+  }
+  if (step?.waitEventId) {
+    return {
+      headers: {
+        ...baseHeaders,
+        "Upstash-Workflow-CallType": "step"
+      },
+      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"]
+      }
+    };
+  }
+  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`
+    );
+  }
+};
+var prepareFlowControl = (flowControl) => {
+  const parallelism = flowControl.parallelism?.toString();
+  const rate = flowControl.ratePerSecond?.toString();
+  const controlValue = [
+    parallelism ? `parallelism=${parallelism}` : void 0,
+    rate ? `rate=${rate}` : void 0
+  ].filter(Boolean);
+  if (controlValue.length === 0) {
+    throw new QstashError3("Provide at least one of parallelism or ratePerSecond for flowControl");
+  }
+  return {
+    flowControlKey: flowControl.key,
+    flowControlValue: controlValue.join(", ")
+  };
+};
+
+// src/serve/serve-many.ts
+var getWorkflowId = (url) => {
+  const components = url.split("/");
+  const lastComponent = components[components.length - 1];
+  return lastComponent.split("?")[0];
+};
+var serveManyBase = ({
+  workflows,
+  getUrl,
+  serveMethod,
+  options
+}) => {
+  const workflowIds = [];
+  const workflowMap = Object.fromEntries(
+    Object.entries(workflows).map((workflow) => {
+      const workflowId = workflow[0];
+      if (workflowIds.includes(workflowId)) {
+        throw new WorkflowError(
+          `Duplicate workflow name found: '${workflowId}'. Please set different workflow names in serveMany.`
+        );
+      }
+      if (workflowId.includes("/")) {
+        throw new WorkflowError(
+          `Invalid workflow name found: '${workflowId}'. Workflow name cannot contain '/'.`
+        );
+      }
+      workflowIds.push(workflowId);
+      workflow[1].workflowId = workflowId;
+      workflow[1].options = {
+        ...options,
+        ...workflow[1].options
+      };
+      const params = [workflow[1].routeFunction, workflow[1].options];
+      const handler = serveMethod(...params);
+      return [workflowId, handler];
+    })
+  );
+  return {
+    handler: async (...params) => {
+      const url = getUrl(...params);
+      const pickedWorkflowId = getWorkflowId(url);
+      if (!pickedWorkflowId) {
+        return new Response(
+          `Unexpected request in serveMany. workflowId not set. Please update the URL of your request.`,
+          {
+            status: 404
+          }
+        );
+      }
+      const workflow = workflowMap[pickedWorkflowId];
+      if (!workflow) {
+        return new Response(
+          `No workflows in serveMany found for '${pickedWorkflowId}'. Please update the URL of your request.`,
+          {
+            status: 404
+          }
+        );
+      }
+      return await workflow(...params);
+    }
+  };
+};
+var invokeWorkflow = async ({
+  settings,
+  invokeStep,
+  context,
+  invokeCount,
+  telemetry
+}) => {
+  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,
+    invokeCount,
+    flowControl: context.flowControl
+  });
+  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
+  });
+  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,
+    workflowUrl: context.url,
+    step: invokeStep
+  };
+  await context.qstashClient.publish({
+    headers: triggerHeaders,
+    method: "POST",
+    body: JSON.stringify(request),
+    url: newUrl
+  });
+};
+
+// src/agents/adapters.ts
+import { createOpenAI } from "@ai-sdk/openai";
+import { tool } from "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 createWorkflowOpenAI = (context, config) => {
+  const { baseURL, apiKey } = config ?? {};
+  return createOpenAI({
+    baseURL,
+    apiKey,
+    compatibility: "strict",
+    fetch: async (input, init) => {
+      try {
+        const headers = init?.headers ? Object.fromEntries(new Headers(init.headers).entries()) : {};
+        const body = init?.body ? JSON.parse(init.body) : void 0;
+        const agentName = headers[AGENT_NAME_HEADER];
+        const stepName = agentName ? `Call Agent ${agentName}` : "Call Agent";
+        const responseInfo = await context.call(stepName, {
+          url: input.toString(),
+          method: init?.method,
+          headers,
+          body
+        });
+        const responseHeaders = new Headers(
+          Object.entries(responseInfo.header).reduce(
+            (acc, [key, values]) => {
+              acc[key] = values.join(", ");
+              return acc;
+            },
+            {}
+          )
+        );
+        return new Response(JSON.stringify(responseInfo.body), {
+          status: responseInfo.status,
+          headers: responseHeaders
+        });
+      } catch (error) {
+        if (error instanceof Error && error.name === "WorkflowAbort") {
+          throw error;
+        } else {
+          console.error("Error in fetch implementation:", error);
+          throw error;
+        }
+      }
+    }
+  });
+};
+var wrapTools = ({
+  context,
+  tools
+}) => {
+  return Object.fromEntries(
+    Object.entries(tools).map((toolInfo) => {
+      const [toolName, tool3] = toolInfo;
+      const executeAsStep = "executeAsStep" in tool3 ? tool3.executeAsStep : true;
+      const aiSDKTool = convertToAISDKTool(tool3);
+      const execute = aiSDKTool.execute;
+      if (execute && executeAsStep) {
+        const wrappedExecute = (...params) => {
+          return context.run(`Run tool ${toolName}`, () => execute(...params));
+        };
+        aiSDKTool.execute = wrappedExecute;
+      }
+      return [toolName, aiSDKTool];
+    })
+  );
+};
+var convertToAISDKTool = (tool3) => {
+  const isLangchainTool = "invoke" in tool3;
+  return isLangchainTool ? convertLangchainTool(tool3) : tool3;
+};
+var convertLangchainTool = (langchainTool) => {
+  return tool({
+    description: langchainTool.description,
+    parameters: langchainTool.schema,
+    execute: async (...param) => langchainTool.invoke(...param)
+  });
+};
+var WorkflowTool = class {
+  /**
+   * description of the tool
+   */
+  description;
+  /**
+   * schema of the tool
+   */
+  schema;
+  /**
+   * function to invoke the tool
+   */
+  invoke;
+  /**
+   * whether the invoke method of the tool is to be wrapped with `context.run`
+   */
+  executeAsStep;
+  /**
+   *
+   * @param description description of the tool
+   * @param schema schema of the tool
+   * @param invoke function to invoke the tool
+   * @param executeAsStep whether the invoke method of the tool is to be wrapped with `context.run`
+   */
+  constructor(params) {
+    this.description = params.description;
+    this.schema = params.schema;
+    this.invoke = params.invoke;
+    this.executeAsStep = params.executeAsStep ?? true;
+  }
+};
+
+// src/context/steps.ts
+var BaseLazyStep = class {
+  stepName;
+  // will be set in the subclasses
+  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;
+  }
+};
+var LazyFunctionStep = class extends BaseLazyStep {
+  stepFunction;
+  stepType = "Run";
+  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";
+  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
+    });
+  }
+};
+var LazySleepUntilStep = class extends BaseLazyStep {
+  sleepUntil;
+  stepType = "SleepUntil";
+  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
+    });
+  }
+};
+var LazyCallStep = class extends BaseLazyStep {
+  url;
+  method;
+  body;
+  headers;
+  retries;
+  timeout;
+  flowControl;
+  stepType = "Call";
+  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
     };
   }
-  if (step?.waitEventId) {
+  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
+    });
+  }
+};
+var LazyWaitForEventStep = class extends BaseLazyStep {
+  eventId;
+  timeout;
+  stepType = "Wait";
+  constructor(stepName, eventId, timeout) {
+    super(stepName);
+    this.eventId = eventId;
+    this.timeout = timeout;
+  }
+  getPlanStep(concurrent, targetStep) {
     return {
-      headers: {
-        ...baseHeaders,
-        "Upstash-Workflow-CallType": "step"
-      },
-      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"]
-      }
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      waitEventId: this.eventId,
+      timeout: this.timeout,
+      concurrent,
+      targetStep
     };
   }
-  return { headers: baseHeaders };
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      waitEventId: this.eventId,
+      timeout: this.timeout,
+      concurrent
+    });
+  }
 };
-var verifyRequest = async (body, signature, verifier) => {
-  if (!verifier) {
-    return;
+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
+      };
+    });
   }
-  try {
-    if (!signature) {
-      throw new Error("`Upstash-Signature` header is not passed.");
-    }
-    const isValid = await verifier.verify({
+};
+var LazyInvokeStep = class extends BaseLazyStep {
+  stepType = "Invoke";
+  params;
+  constructor(stepName, {
+    workflow,
+    body,
+    headers = {},
+    workflowRunId,
+    retries,
+    flowControl
+  }) {
+    super(stepName);
+    this.params = {
+      workflow,
       body,
-      signature
+      headers,
+      workflowRunId: getWorkflowRunId(workflowRunId),
+      retries,
+      flowControl
+    };
+  }
+  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
     });
-    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`
-    );
   }
 };
 
@@ -1199,14 +1525,16 @@ var AutoExecutor = class _AutoExecutor {
   nonPlanStepCount;
   steps;
   indexInCurrentList = 0;
+  invokeCount;
   telemetry;
   stepCount = 0;
   planStepCount = 0;
   executingStep = false;
-  constructor(context, steps, telemetry, debug) {
+  constructor(context, steps, telemetry, invokeCount, debug) {
     this.context = context;
     this.steps = steps;
     this.telemetry = telemetry;
+    this.invokeCount = invokeCount ?? 0;
     this.debug = debug;
     this.nonPlanStepCount = this.steps.filter((step) => !step.targetStep).length;
   }
@@ -1429,7 +1757,9 @@ var AutoExecutor = class _AutoExecutor {
         step: waitStep,
         failureUrl: this.context.failureUrl,
         retries: this.context.retries,
-        telemetry: this.telemetry
+        telemetry: this.telemetry,
+        invokeCount: this.invokeCount,
+        flowControl: this.context.flowControl
       });
       const waitBody = {
         url: this.context.url,
@@ -1457,17 +1787,13 @@ var AutoExecutor = class _AutoExecutor {
     if (steps.length === 1 && lazySteps[0] instanceof LazyInvokeStep) {
       const invokeStep = steps[0];
       const lazyInvokeStep = lazySteps[0];
-      await lazyInvokeStep.params.workflow.callback(
-        {
-          body: lazyInvokeStep.params.body,
-          headers: lazyInvokeStep.params.headers,
-          workflowRunId: lazyInvokeStep.params.workflowRunId,
-          workflow: lazyInvokeStep.params.workflow,
-          retries: lazyInvokeStep.params.retries
-        },
+      await invokeWorkflow({
+        settings: lazyInvokeStep.params,
         invokeStep,
-        this.context
-      );
+        context: this.context,
+        invokeCount: this.invokeCount,
+        telemetry: this.telemetry
+      });
       throw new WorkflowAbort(invokeStep.stepName, invokeStep);
     }
     const result = await this.context.qstashClient.batchJSON(
@@ -1483,11 +1809,14 @@ var AutoExecutor = class _AutoExecutor {
           retries: this.context.retries,
           callRetries: lazyStep instanceof LazyCallStep ? lazyStep.retries : void 0,
           callTimeout: lazyStep instanceof LazyCallStep ? lazyStep.timeout : void 0,
-          telemetry: this.telemetry
+          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 ? (
+        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
@@ -1719,98 +2048,6 @@ var WorkflowApi = class extends BaseWorkflowApi {
   }
 };
 
-// src/agents/adapters.ts
-import { createOpenAI } from "@ai-sdk/openai";
-import { tool } from "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 createWorkflowOpenAI = (context, config) => {
-  const { baseURL, apiKey } = config ?? {};
-  return createOpenAI({
-    baseURL,
-    apiKey,
-    compatibility: "strict",
-    fetch: async (input, init) => {
-      try {
-        const headers = init?.headers ? Object.fromEntries(new Headers(init.headers).entries()) : {};
-        const body = init?.body ? JSON.parse(init.body) : void 0;
-        const agentName = headers[AGENT_NAME_HEADER];
-        const stepName = agentName ? `Call Agent ${agentName}` : "Call Agent";
-        const responseInfo = await context.call(stepName, {
-          url: input.toString(),
-          method: init?.method,
-          headers,
-          body
-        });
-        const responseHeaders = new Headers(
-          Object.entries(responseInfo.header).reduce(
-            (acc, [key, values]) => {
-              acc[key] = values.join(", ");
-              return acc;
-            },
-            {}
-          )
-        );
-        return new Response(JSON.stringify(responseInfo.body), {
-          status: responseInfo.status,
-          headers: responseHeaders
-        });
-      } catch (error) {
-        if (error instanceof Error && error.name === "WorkflowAbort") {
-          throw error;
-        } else {
-          console.error("Error in fetch implementation:", error);
-          throw error;
-        }
-      }
-    }
-  });
-};
-var wrapTools = ({
-  context,
-  tools
-}) => {
-  return Object.fromEntries(
-    Object.entries(tools).map((toolInfo) => {
-      const [toolName, tool3] = toolInfo;
-      const aiSDKTool = convertToAISDKTool(tool3);
-      const execute = aiSDKTool.execute;
-      if (execute) {
-        const wrappedExecute = (...params) => {
-          return context.run(`Run tool ${toolName}`, () => execute(...params));
-        };
-        aiSDKTool.execute = wrappedExecute;
-      }
-      return [toolName, aiSDKTool];
-    })
-  );
-};
-var convertToAISDKTool = (tool3) => {
-  const isLangchainTool = "invoke" in tool3;
-  return isLangchainTool ? convertLangchainTool(tool3) : tool3;
-};
-var convertLangchainTool = (langchainTool) => {
-  return tool({
-    description: langchainTool.description,
-    parameters: langchainTool.schema,
-    execute: async (...param) => langchainTool.invoke(...param)
-  });
-};
-
 // src/agents/agent.ts
 import { z } from "zod";
 import { generateText, tool as tool2, ToolExecutionError } from "ai";
@@ -2143,6 +2380,11 @@ var WorkflowContext = class {
    * Number of retries
    */
   retries;
+  /**
+   * Settings for controlling the number of active requests
+   * and number of requests per second with the same key.
+   */
+  flowControl;
   constructor({
     qstashClient,
     workflowRunId,
@@ -2154,7 +2396,9 @@ var WorkflowContext = class {
     initialPayload,
     env,
     retries,
-    telemetry
+    telemetry,
+    invokeCount,
+    flowControl
   }) {
     this.qstashClient = qstashClient;
     this.workflowRunId = workflowRunId;
@@ -2165,7 +2409,8 @@ var WorkflowContext = class {
     this.requestPayload = initialPayload;
     this.env = env ?? {};
     this.retries = retries ?? DEFAULT_RETRIES;
-    this.executor = new AutoExecutor(this, this.steps, telemetry, debug);
+    this.flowControl = flowControl;
+    this.executor = new AutoExecutor(this, this.steps, telemetry, invokeCount, debug);
   }
   /**
    * Executes a workflow step
@@ -2267,7 +2512,7 @@ var WorkflowContext = class {
    *   }
    */
   async call(stepName, settings) {
-    const { url, method = "GET", body, headers = {}, retries = 0, timeout } = settings;
+    const { url, method = "GET", body, headers = {}, retries = 0, timeout, flowControl } = settings;
     const result = await this.addStep(
       new LazyCallStep(
         stepName,
@@ -2276,7 +2521,8 @@ var WorkflowContext = class {
         body,
         headers,
         retries,
-        timeout
+        timeout,
+        flowControl
       )
     );
     if (typeof result === "string") {
@@ -2513,7 +2759,8 @@ var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowCon
       failureUrl: context.failureUrl,
       initialPayload: context.requestPayload,
       env: context.env,
-      retries: context.retries
+      retries: context.retries,
+      flowControl: context.flowControl
     });
     try {
       await routeFunction(disabledContext);
@@ -2666,7 +2913,7 @@ var parseRequest = async (requestPayload, isFirstInvocation, workflowRunId, requ
     };
   }
 };
-var handleFailure = async (request, requestPayload, qstashClient, initialPayloadParser, routeFunction, failureFunction, env, retries, debug) => {
+var handleFailure = async (request, requestPayload, qstashClient, initialPayloadParser, routeFunction, failureFunction, env, retries, flowControl, debug) => {
   if (request.headers.get(WORKFLOW_FAILURE_HEADER) !== "true") {
     return ok("not-failure-callback");
   }
@@ -2678,22 +2925,21 @@ var handleFailure = async (request, requestPayload, qstashClient, initialPayload
     );
   }
   try {
-    const { status, header, body, url, sourceHeader, sourceBody, workflowRunId } = JSON.parse(
-      requestPayload
-    );
+    const { status, header, body, url, sourceBody, workflowRunId } = JSON.parse(requestPayload);
     const decodedBody = body ? decodeBase64(body) : "{}";
     const errorPayload = JSON.parse(decodedBody);
     const workflowContext = new WorkflowContext({
       qstashClient,
       workflowRunId,
       initialPayload: sourceBody ? initialPayloadParser(decodeBase64(sourceBody)) : void 0,
-      headers: recreateUserHeaders(new Headers(sourceHeader)),
+      headers: recreateUserHeaders(request.headers),
       steps: [],
       url,
       failureUrl: url,
       debug,
       env,
       retries,
+      flowControl,
       telemetry: void 0
       // not going to make requests in authentication check
     });
@@ -2820,7 +3066,8 @@ var serveBase = (routeFunction, telemetry, options) => {
     env,
     retries,
     useJSONContent,
-    disableTelemetry
+    disableTelemetry,
+    flowControl
   } = processOptions(options);
   telemetry = disableTelemetry ? void 0 : telemetry;
   const debug = WorkflowLogger.getLogger(verbose);
@@ -2861,6 +3108,7 @@ var serveBase = (routeFunction, telemetry, options) => {
       failureFunction,
       env,
       retries,
+      flowControl,
       debug
     );
     if (failureCheck.isErr()) {
@@ -2869,6 +3117,7 @@ var serveBase = (routeFunction, telemetry, options) => {
       await debug?.log("WARN", "RESPONSE_DEFAULT", "failureFunction executed");
       return onStepFinish(workflowRunId, "failure-callback");
     }
+    const invokeCount = Number(request.headers.get(WORKFLOW_INVOKE_COUNT_HEADER) ?? "0");
     const workflowContext = new WorkflowContext({
       qstashClient,
       workflowRunId,
@@ -2880,7 +3129,9 @@ var serveBase = (routeFunction, telemetry, options) => {
       debug,
       env,
       retries,
-      telemetry
+      telemetry,
+      invokeCount,
+      flowControl
     });
     const authCheck = await DisabledWorkflowContext.tryAuthentication(
       routeFunction,
@@ -2903,6 +3154,7 @@ var serveBase = (routeFunction, telemetry, options) => {
       workflowUrl,
       failureUrl: workflowFailureUrl,
       retries,
+      flowControl,
       telemetry,
       debug
     });
@@ -2912,7 +3164,13 @@ var serveBase = (routeFunction, telemetry, options) => {
       });
       throw callReturnCheck.error;
     } else if (callReturnCheck.value === "continue-workflow") {
-      const result = isFirstInvocation ? await triggerFirstInvocation({ workflowContext, useJSONContent, telemetry, debug }) : await triggerRouteFunction({
+      const result = isFirstInvocation ? await triggerFirstInvocation({
+        workflowContext,
+        useJSONContent,
+        telemetry,
+        debug,
+        invokeCount
+      }) : await triggerRouteFunction({
         onStep: async () => routeFunction(workflowContext),
         onCleanup: async (result2) => {
           await triggerWorkflowDelete(workflowContext, result2, debug);
@@ -2969,7 +3227,8 @@ export {
   getWorkflowRunId,
   StepTypes,
   triggerFirstInvocation,
-  getHeaders,
+  serveManyBase,
+  WorkflowTool,
   WorkflowContext,
   WorkflowLogger,
   serveBase,