@upstash/workflow 0.2.22-rc → 0.2.23-rc

package/index.js

@@ -27,13 +27,102 @@ __export(src_exports, {
   WorkflowError: () => WorkflowError,
   WorkflowLogger: () => WorkflowLogger,
   WorkflowNonRetryableError: () => WorkflowNonRetryableError,
+  WorkflowRetryAfterError: () => WorkflowRetryAfterError,
   WorkflowTool: () => WorkflowTool,
   serve: () => serve
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/client/utils.ts
+var import_qstash2 = require("@upstash/qstash");
+
+// src/error.ts
 var import_qstash = require("@upstash/qstash");
+var WorkflowError = class extends import_qstash.QstashError {
+  constructor(message) {
+    super(message);
+    this.name = "WorkflowError";
+  }
+};
+var WorkflowAbort = class extends Error {
+  stepInfo;
+  stepName;
+  /**
+   * whether workflow is to be canceled on abort
+   */
+  cancelWorkflow;
+  /**
+   *
+   * @param stepName name of the aborting step
+   * @param stepInfo step information
+   * @param cancelWorkflow
+   */
+  constructor(stepName, stepInfo, cancelWorkflow = false) {
+    super(
+      `This is an Upstash Workflow error thrown after a step executes. It is expected to be raised. Make sure that you await for each step. Also, if you are using try/catch blocks, you should not wrap context.run/sleep/sleepUntil/call methods with try/catch. Aborting workflow after executing step '${stepName}'.`
+    );
+    this.name = "WorkflowAbort";
+    this.stepName = stepName;
+    this.stepInfo = stepInfo;
+    this.cancelWorkflow = cancelWorkflow;
+  }
+};
+var WorkflowNonRetryableError = class extends WorkflowAbort {
+  /**
+   * @param message error message to be displayed
+   */
+  constructor(message) {
+    super("fail", void 0, false);
+    this.name = "WorkflowNonRetryableError";
+    if (message) this.message = message;
+  }
+};
+var WorkflowRetryAfterError = class extends WorkflowAbort {
+  retryAfter;
+  /**
+   * @param retryAfter time in seconds after which the workflow should be retried
+   * @param message error message to be displayed
+   */
+  constructor(message, retryAfter) {
+    super("retry", void 0, false);
+    this.name = "WorkflowRetryAfterError";
+    this.retryAfter = retryAfter;
+    if (message) this.message = message;
+  }
+};
+var formatWorkflowError = (error) => {
+  return error instanceof Error ? {
+    error: error.name,
+    message: error.message,
+    stack: error.stack
+  } : {
+    error: "Error",
+    message: `An error occured while executing workflow: '${typeof error === "string" ? error : JSON.stringify(error)}'`
+  };
+};
+function getConstructorName(obj) {
+  if (obj === null || obj === void 0) {
+    return null;
+  }
+  const ctor = obj.constructor;
+  if (!ctor || ctor.name === "Object") {
+    return null;
+  }
+  return ctor.name;
+}
+function getConstructorNames(obj) {
+  const proto = Object.getPrototypeOf(obj);
+  const name = getConstructorName(proto);
+  if (name === null) {
+    return [];
+  }
+  return [name, ...getConstructorNames(proto)];
+}
+function isInstanceOf(v, ctor) {
+  return getConstructorNames(v).includes(ctor.name);
+}
+
+// src/client/utils.ts
 var makeNotifyRequest = async (requester, eventId, eventData) => {
   const result = await requester.request({
     path: ["v2", "notify", eventId],
@@ -80,7 +169,7 @@ var getSteps = async (requester, workflowRunId, messageId, debug) => {
       return { steps: filteredSteps, workflowRunEnded: false };
     }
   } catch (error) {
-    if (error instanceof import_qstash.QstashError && error.status === 404) {
+    if (isInstanceOf(error, import_qstash2.QstashError) && 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
@@ -105,65 +194,13 @@ 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.21";
+var VERSION = "v0.2.22";
 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");
-var WorkflowError = class extends import_qstash2.QstashError {
-  constructor(message) {
-    super(message);
-    this.name = "WorkflowError";
-  }
-};
-var WorkflowAbort = class extends Error {
-  stepInfo;
-  stepName;
-  /**
-   * whether workflow is to be canceled on abort
-   */
-  cancelWorkflow;
-  /**
-   *
-   * @param stepName name of the aborting step
-   * @param stepInfo step information
-   * @param cancelWorkflow
-   */
-  constructor(stepName, stepInfo, cancelWorkflow = false) {
-    super(
-      `This is an Upstash Workflow error thrown after a step executes. It is expected to be raised. Make sure that you await for each step. Also, if you are using try/catch blocks, you should not wrap context.run/sleep/sleepUntil/call methods with try/catch. Aborting workflow after executing step '${stepName}'.`
-    );
-    this.name = "WorkflowAbort";
-    this.stepName = stepName;
-    this.stepInfo = stepInfo;
-    this.cancelWorkflow = cancelWorkflow;
-  }
-};
-var WorkflowNonRetryableError = class extends WorkflowAbort {
-  /**
-   * @param message error message to be displayed
-   */
-  constructor(message) {
-    super("fail", void 0, false);
-    this.name = "WorkflowNonRetryableError";
-    if (message) this.message = message;
-  }
-};
-var formatWorkflowError = (error) => {
-  return error instanceof Error ? {
-    error: error.name,
-    message: error.message,
-    stack: error.stack
-  } : {
-    error: "Error",
-    message: `An error occured while executing workflow: '${typeof error === "string" ? error : JSON.stringify(error)}'`
-  };
-};
-
 // src/context/auto-executor.ts
 var import_qstash5 = require("@upstash/qstash");
 
@@ -176,8 +213,8 @@ var NANOID_LENGTH = 21;
 function getRandomInt() {
   return Math.floor(Math.random() * NANOID_CHARS.length);
 }
-function nanoid() {
-  return Array.from({ length: NANOID_LENGTH }).map(() => NANOID_CHARS[getRandomInt()]).join("");
+function nanoid(length = NANOID_LENGTH) {
+  return Array.from({ length }).map(() => NANOID_CHARS[getRandomInt()]).join("");
 }
 function getWorkflowRunId(id) {
   return `wfr_${id ?? nanoid()}`;
@@ -194,6 +231,37 @@ function decodeBase64(base64) {
     return binString;
   }
 }
+function getUserIdFromToken(qstashClient) {
+  try {
+    const token = qstashClient.token;
+    const decodedToken = decodeBase64(token);
+    const tokenPayload = JSON.parse(decodedToken);
+    const userId = tokenPayload.UserID;
+    if (!userId) {
+      throw new WorkflowError("QStash token payload does not contain userId");
+    }
+    return userId;
+  } catch (error) {
+    throw new WorkflowError(
+      `Failed to decode QStash token while running create webhook step: ${error.message}`
+    );
+  }
+}
+function getQStashUrl(qstashClient) {
+  try {
+    const requester = qstashClient.http;
+    const baseUrl = requester.baseUrl;
+    if (!baseUrl) {
+      throw new WorkflowError("QStash client does not have a baseUrl");
+    }
+    return baseUrl;
+  } catch (error) {
+    throw new WorkflowError(`Failed to get QStash URL from client: ${error.message}`);
+  }
+}
+function getEventId() {
+  return `evt_${nanoid(15)}`;
+}
 
 // node_modules/neverthrow/dist/index.es.js
 var defaultErrorConfig = {
@@ -619,7 +687,9 @@ var StepTypes = [
   "Call",
   "Wait",
   "Notify",
-  "Invoke"
+  "Invoke",
+  "CreateWebhook",
+  "WaitForWebhook"
 ];
 
 // src/workflow-requests.ts
@@ -723,17 +793,17 @@ var triggerRouteFunction = async ({
     return ok("workflow-finished");
   } catch (error) {
     const error_ = error;
-    if (error instanceof import_qstash3.QstashError && error.status === 400) {
+    if (isInstanceOf(error, import_qstash3.QstashError) && error.status === 400) {
       await debug?.log("WARN", "RESPONSE_WORKFLOW", {
         message: `tried to append to a cancelled workflow. exiting without publishing.`,
         name: error.name,
         errorMessage: error.message
       });
       return ok("workflow-was-finished");
-    } else if (!(error_ instanceof WorkflowAbort)) {
-      return err(error_);
-    } else if (error_ instanceof WorkflowNonRetryableError) {
+    } else if (isInstanceOf(error_, WorkflowNonRetryableError) || isInstanceOf(error_, WorkflowRetryAfterError)) {
       return ok(error_);
+    } else if (!isInstanceOf(error_, WorkflowAbort)) {
+      return err(error_);
     } else if (error_.cancelWorkflow) {
       await onCancel();
       return ok("workflow-finished");
@@ -931,7 +1001,9 @@ If you want to disable QStash Verification, you should clear env variables QSTAS
 // src/context/steps.ts
 var BaseLazyStep = class _BaseLazyStep {
   stepName;
-  constructor(stepName) {
+  context;
+  constructor(context, stepName) {
+    this.context = context;
     if (!stepName) {
       throw new WorkflowError(
         "A workflow step name cannot be undefined or an empty string. Please provide a name for your workflow step."
@@ -949,13 +1021,14 @@ var BaseLazyStep = class _BaseLazyStep {
    *
    * will be called when returning the steps to the context from auto executor
    *
-   * @param out field of the step
+   * @param step step
    * @returns parsed out field
    */
-  parseOut(out) {
+  parseOut(step) {
+    const out = step.out;
     if (out === void 0) {
       if (this.allowUndefinedOut) {
-        return void 0;
+        return this.handleUndefinedOut(step);
       } else {
         throw new WorkflowError(
           `Error while parsing output of ${this.stepType} step. Expected a string, but got: undefined`
@@ -963,27 +1036,26 @@ var BaseLazyStep = class _BaseLazyStep {
       }
     }
     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)
-      };
+      console.warn(
+        `Error while parsing ${this.stepType} step output. Expected a string, but got object. Please reach out to Upstash Support.`
+      );
+      return out;
     }
     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);
+    return this.safeParseOut(out, step);
   }
-  safeParseOut(out) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  safeParseOut(out, step) {
     return _BaseLazyStep.tryParsing(out);
   }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  handleUndefinedOut(step) {
+    return void 0;
+  }
   static tryParsing(stepOut) {
     try {
       return JSON.parse(stepOut);
@@ -1034,8 +1106,8 @@ var LazyFunctionStep = class extends BaseLazyStep {
   stepFunction;
   stepType = "Run";
   allowUndefinedOut = true;
-  constructor(stepName, stepFunction) {
-    super(stepName);
+  constructor(context, stepName, stepFunction) {
+    super(context, stepName);
     this.stepFunction = stepFunction;
   }
   getPlanStep(concurrent, targetStep) {
@@ -1065,8 +1137,8 @@ var LazySleepStep = class extends BaseLazyStep {
   sleep;
   stepType = "SleepFor";
   allowUndefinedOut = true;
-  constructor(stepName, sleep) {
-    super(stepName);
+  constructor(context, stepName, sleep) {
+    super(context, stepName);
     this.sleep = sleep;
   }
   getPlanStep(concurrent, targetStep) {
@@ -1107,8 +1179,8 @@ var LazySleepUntilStep = class extends BaseLazyStep {
   sleepUntil;
   stepType = "SleepUntil";
   allowUndefinedOut = true;
-  constructor(stepName, sleepUntil) {
-    super(stepName);
+  constructor(context, stepName, sleepUntil) {
+    super(context, stepName);
     this.sleepUntil = sleepUntil;
   }
   getPlanStep(concurrent, targetStep) {
@@ -1160,8 +1232,8 @@ var LazyCallStep = class _LazyCallStep extends BaseLazyStep {
   stringifyBody;
   stepType = "Call";
   allowUndefinedOut = false;
-  constructor(stepName, url, method, body, headers, retries, retryDelay, timeout, flowControl, stringifyBody) {
-    super(stepName);
+  constructor(context, stepName, url, method, body, headers, retries, retryDelay, timeout, flowControl, stringifyBody) {
+    super(context, stepName);
     this.url = url;
     this.method = method;
     this.body = body;
@@ -1305,13 +1377,12 @@ var LazyCallStep = class _LazyCallStep extends BaseLazyStep {
     ]);
   }
 };
-var LazyWaitForEventStep = class extends BaseLazyStep {
+var LazyWaitEventStep = class extends BaseLazyStep {
   eventId;
   timeout;
-  stepType = "Wait";
   allowUndefinedOut = false;
-  constructor(stepName, eventId, timeout) {
-    super(stepName);
+  constructor(context, stepName, eventId, timeout) {
+    super(context, stepName);
     this.eventId = eventId;
     this.timeout = timeout;
   }
@@ -1336,13 +1407,6 @@ var LazyWaitForEventStep = class extends BaseLazyStep {
       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";
@@ -1376,7 +1440,7 @@ var LazyWaitForEventStep = class extends BaseLazyStep {
       timeoutHeaders,
       step: {
         stepId: step.stepId,
-        stepType: "Wait",
+        stepType: this.stepType,
         stepName: step.stepName,
         concurrent: step.concurrent,
         targetStep: step.targetStep
@@ -1397,8 +1461,8 @@ var LazyWaitForEventStep = class extends BaseLazyStep {
 };
 var LazyNotifyStep = class extends LazyFunctionStep {
   stepType = "Notify";
-  constructor(stepName, eventId, eventData, requester) {
-    super(stepName, async () => {
+  constructor(context, stepName, eventId, eventData, requester) {
+    super(context, stepName, async () => {
       const notifyResponse = await makeNotifyRequest(requester, eventId, eventData);
       return {
         eventId,
@@ -1423,7 +1487,7 @@ var LazyInvokeStep = class extends BaseLazyStep {
    * workflow id of the invoked workflow
    */
   workflowId;
-  constructor(stepName, {
+  constructor(context, stepName, {
     workflow,
     body,
     headers = {},
@@ -1433,7 +1497,7 @@ var LazyInvokeStep = class extends BaseLazyStep {
     flowControl,
     stringifyBody = true
   }) {
-    super(stepName);
+    super(context, stepName);
     this.params = {
       workflow,
       body,
@@ -1494,6 +1558,9 @@ var LazyInvokeStep = class extends BaseLazyStep {
       userHeaders: context.headers,
       invokeCount
     });
+    context.qstashClient.http.headers?.forEach((value, key) => {
+      invokerHeaders[key] = value;
+    });
     invokerHeaders["Upstash-Workflow-Runid"] = context.workflowRunId;
     let invokeBody;
     if (this.params.stringifyBody) {
@@ -1565,6 +1632,91 @@ var LazyInvokeStep = class extends BaseLazyStep {
     return [result];
   }
 };
+var LazyCreateWebhookStep = class extends BaseLazyStep {
+  stepType = "CreateWebhook";
+  allowUndefinedOut = false;
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    return {
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      out: void 0,
+      concurrent
+    };
+  }
+  getBody({ step, context }) {
+    const userId = getUserIdFromToken(context.qstashClient);
+    const out = [userId, context.workflowRunId, getEventId()].join("/");
+    return JSON.stringify({
+      ...step,
+      out
+    });
+  }
+  safeParseOut(out) {
+    const [userId, workflowRunId, eventId] = out.split("/");
+    const qstashUrl = getQStashUrl(this.context.qstashClient);
+    return {
+      webhookUrl: `${qstashUrl}/v2/workflows/hooks/${userId}/${workflowRunId}/${eventId}`,
+      eventId
+    };
+  }
+};
+var LazyWaitForWebhookStep = class extends LazyWaitEventStep {
+  stepType = "WaitForWebhook";
+  allowUndefinedOut = true;
+  constructor(context, stepName, webhook, timeout) {
+    super(context, stepName, webhook.eventId, timeout);
+  }
+  safeParseOut(out) {
+    const eventData = decodeBase64(out);
+    const parsedEventData = BaseLazyStep.tryParsing(eventData);
+    const body = parsedEventData.body;
+    const parsedBody = typeof body === "string" ? decodeBase64(body) : void 0;
+    const request = new Request(
+      `${parsedEventData.proto}://${parsedEventData.host}${parsedEventData.url}`,
+      {
+        method: parsedEventData.method,
+        headers: parsedEventData.header,
+        body: parsedBody
+      }
+    );
+    return {
+      request,
+      timeout: false
+    };
+  }
+  handleUndefinedOut() {
+    return {
+      timeout: true,
+      request: void 0
+    };
+  }
+};
+var LazyWaitForEventStep = class extends LazyWaitEventStep {
+  stepType = "Wait";
+  allowUndefinedOut = true;
+  parseWaitForEventOut(out, waitTimeout) {
+    return {
+      eventData: out ? BaseLazyStep.tryParsing(decodeBase64(out)) : void 0,
+      timeout: waitTimeout ?? false
+    };
+  }
+  safeParseOut(out, step) {
+    return this.parseWaitForEventOut(out, step.waitTimeout);
+  }
+  handleUndefinedOut(step) {
+    return this.parseWaitForEventOut(void 0, step.waitTimeout);
+  }
+};
 
 // src/agents/constants.ts
 var AGENT_NAME_HEADER = "upstash-agent-name";
@@ -1969,7 +2121,7 @@ var AutoExecutor = class _AutoExecutor {
         step,
         stepCount: this.stepCount
       });
-      return lazyStep.parseOut(step.out);
+      return lazyStep.parseOut(step);
     }
     const resultStep = await submitSingleStep({
       context: this.context,
@@ -2040,7 +2192,7 @@ var AutoExecutor = class _AutoExecutor {
           });
           throw new WorkflowAbort(parallelStep.stepName, resultStep);
         } catch (error) {
-          if (error instanceof WorkflowAbort || error instanceof import_qstash5.QstashError && error.status === 400) {
+          if (isInstanceOf(error, WorkflowAbort) || isInstanceOf(error, import_qstash5.QstashError) && error.status === 400) {
             throw error;
           }
           throw new WorkflowError(
@@ -2056,7 +2208,7 @@ var AutoExecutor = class _AutoExecutor {
         const parallelResultSteps = sortedSteps.filter((step) => step.stepId >= initialStepCount).slice(0, parallelSteps.length);
         validateParallelSteps(parallelSteps, parallelResultSteps);
         return parallelResultSteps.map(
-          (step, index) => parallelSteps[index].parseOut(step.out)
+          (step, index) => parallelSteps[index].parseOut(step)
         );
       }
     }
@@ -2112,7 +2264,6 @@ var AutoExecutor = class _AutoExecutor {
    * @param index index of the current step
    * @returns result[index] if lazyStepList > 1, otherwise result
    */
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
   static getResult(lazyStepList, result, index) {
     if (lazyStepList.length === 1) {
       return result;
@@ -2147,7 +2298,7 @@ var validateParallelSteps = (lazySteps, stepsFromRequest) => {
       validateStep(lazySteps[index], stepFromRequest);
     }
   } catch (error) {
-    if (error instanceof WorkflowError) {
+    if (isInstanceOf(error, WorkflowError)) {
       const lazyStepNames = lazySteps.map((lazyStep) => lazyStep.stepName);
       const lazyStepTypes = lazySteps.map((lazyStep) => lazyStep.stepType);
       const requestStepNames = stepsFromRequest.map((step) => step.stepName);
@@ -2328,7 +2479,7 @@ var fetchWithContextCall = async (context, agentCallParams, ...params) => {
       headers: responseHeaders
     });
   } catch (error) {
-    if (error instanceof Error && error.name === "WorkflowAbort") {
+    if (error instanceof Error && isInstanceOf(error, WorkflowAbort)) {
       throw error;
     } else {
       console.error("Error in fetch implementation:", error);
@@ -2461,10 +2612,10 @@ var Agent = class {
       });
       return { text: result.text };
     } catch (error) {
-      if (error instanceof import_ai2.ToolExecutionError) {
-        if (error.cause instanceof Error && error.cause.name === "WorkflowAbort") {
+      if (isInstanceOf(error, import_ai2.ToolExecutionError)) {
+        if (error.cause instanceof Error && isInstanceOf(error.cause, WorkflowAbort)) {
           throw error.cause;
-        } else if (error.cause instanceof import_ai2.ToolExecutionError && error.cause.cause instanceof Error && error.cause.cause.name === "WorkflowAbort") {
+        } else if (isInstanceOf(error.cause, import_ai2.ToolExecutionError) && isInstanceOf(error.cause.cause, WorkflowAbort)) {
           throw error.cause.cause;
         } else {
           throw error;
@@ -2868,7 +3019,7 @@ var WorkflowContext = class {
    */
   async run(stepName, stepFunction) {
     const wrappedStepFunction = () => this.executor.wrapStep(stepName, stepFunction);
-    return await this.addStep(new LazyFunctionStep(stepName, wrappedStepFunction));
+    return await this.addStep(new LazyFunctionStep(this, stepName, wrappedStepFunction));
   }
   /**
    * Stops the execution for the duration provided.
@@ -2882,7 +3033,7 @@ var WorkflowContext = class {
    * @returns undefined
    */
   async sleep(stepName, duration) {
-    await this.addStep(new LazySleepStep(stepName, duration));
+    await this.addStep(new LazySleepStep(this, stepName, duration));
   }
   /**
    * Stops the execution until the date time provided.
@@ -2904,13 +3055,14 @@ var WorkflowContext = class {
       datetime = typeof datetime === "string" ? new Date(datetime) : datetime;
       time = Math.round(datetime.getTime() / 1e3);
     }
-    await this.addStep(new LazySleepUntilStep(stepName, time));
+    await this.addStep(new LazySleepUntilStep(this, stepName, time));
   }
   async call(stepName, settings) {
     let callStep;
     if ("workflow" in settings) {
       const url = getNewUrlFromWorkflowId(this.url, settings.workflow.workflowId);
       callStep = new LazyCallStep(
+        this,
         stepName,
         url,
         "POST",
@@ -2935,6 +3087,7 @@ var WorkflowContext = class {
         stringifyBody = true
       } = settings;
       callStep = new LazyCallStep(
+        this,
         stepName,
         url,
         method,
@@ -2986,7 +3139,9 @@ var WorkflowContext = class {
   async waitForEvent(stepName, eventId, options = {}) {
     const { timeout = "7d" } = options;
     const timeoutStr = typeof timeout === "string" ? timeout : `${timeout}s`;
-    return await this.addStep(new LazyWaitForEventStep(stepName, eventId, timeoutStr));
+    return await this.addStep(
+      new LazyWaitForEventStep(this, stepName, eventId, timeoutStr)
+    );
   }
   /**
    * Notify workflow runs waiting for an event
@@ -3011,11 +3166,19 @@ var WorkflowContext = class {
    */
   async notify(stepName, eventId, eventData) {
     return await this.addStep(
-      new LazyNotifyStep(stepName, eventId, eventData, this.qstashClient.http)
+      new LazyNotifyStep(this, stepName, eventId, eventData, this.qstashClient.http)
     );
   }
   async invoke(stepName, settings) {
-    return await this.addStep(new LazyInvokeStep(stepName, settings));
+    return await this.addStep(
+      new LazyInvokeStep(this, stepName, settings)
+    );
+  }
+  async createWebhook(stepName) {
+    return await this.addStep(new LazyCreateWebhookStep(this, stepName));
+  }
+  async waitForWebhook(stepName, webhook, timeout) {
+    return await this.addStep(new LazyWaitForWebhookStep(this, stepName, webhook, timeout));
   }
   /**
    * Cancel the current workflow run
@@ -3146,7 +3309,7 @@ var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowCon
     try {
       await routeFunction(disabledContext);
     } catch (error) {
-      if (error instanceof WorkflowAbort && error.stepName === this.disabledMessage || error instanceof WorkflowNonRetryableError) {
+      if (isInstanceOf(error, WorkflowAbort) && error.stepName === this.disabledMessage || isInstanceOf(error, WorkflowNonRetryableError) || isInstanceOf(error, WorkflowRetryAfterError)) {
         return ok("step-found");
       }
       console.warn(
@@ -3179,13 +3342,6 @@ var processRawSteps = (rawSteps) => {
   const stepsToDecode = encodedSteps.filter((step) => step.callType === "step");
   const otherSteps = stepsToDecode.map((rawStep) => {
     const step = JSON.parse(decodeBase64(rawStep.body));
-    if (step.waitEventId) {
-      const newOut = {
-        eventData: step.out ? decodeBase64(step.out) : void 0,
-        timeout: step.waitTimeout ?? false
-      };
-      step.out = newOut;
-    }
     return step;
   });
   const steps = [initialStep, ...otherSteps];
@@ -3399,13 +3555,24 @@ var processOptions = (options) => {
           },
           status: 489
         });
-      } else if (detailedFinishCondition?.condition === "failure-callback") {
-        return new Response(detailedFinishCondition.result ?? void 0, {
-          status: 200,
+      } else if (detailedFinishCondition?.condition === "retry-after-error") {
+        return new Response(JSON.stringify(formatWorkflowError(detailedFinishCondition.result)), {
           headers: {
+            "Retry-After": detailedFinishCondition.result.retryAfter.toString(),
             [WORKFLOW_PROTOCOL_VERSION_HEADER]: WORKFLOW_PROTOCOL_VERSION
-          }
+          },
+          status: 429
         });
+      } else if (detailedFinishCondition?.condition === "failure-callback") {
+        return new Response(
+          JSON.stringify({ result: detailedFinishCondition.result ?? void 0 }),
+          {
+            status: 200,
+            headers: {
+              [WORKFLOW_PROTOCOL_VERSION_HEADER]: WORKFLOW_PROTOCOL_VERSION
+            }
+          }
+        );
       }
       return new Response(JSON.stringify({ workflowRunId }), {
         status: 200,
@@ -3615,12 +3782,18 @@ var serveBase = (routeFunction, telemetry, options) => {
         },
         debug
       });
-      if (result.isOk() && result.value instanceof WorkflowNonRetryableError) {
+      if (result.isOk() && isInstanceOf(result.value, WorkflowNonRetryableError)) {
         return onStepFinish(workflowRunId, result.value, {
           condition: "non-retryable-error",
           result: result.value
         });
       }
+      if (result.isOk() && isInstanceOf(result.value, WorkflowRetryAfterError)) {
+        return onStepFinish(workflowRunId, result.value, {
+          condition: "retry-after-error",
+          result: result.value
+        });
+      }
       if (result.isErr()) {
         await debug?.log("ERROR", "ERROR", { error: result.error.message });
         throw result.error;
@@ -3651,7 +3824,7 @@ var serveBase = (routeFunction, telemetry, options) => {
         const errorMessage = `Error while running onError callback: '${formattedOnErrorError.message}'.
 Original error: '${formattedError.message}'`;
         console.error(errorMessage);
-        return new Response(errorMessage, {
+        return new Response(JSON.stringify({ error: errorMessage }), {
           status: 500,
           headers: {
             [WORKFLOW_PROTOCOL_VERSION_HEADER]: WORKFLOW_PROTOCOL_VERSION
@@ -3920,14 +4093,14 @@ var Client4 = class {
         workflowRunId: finalWorkflowRunId,
         retries: option.retries,
         retryDelay: option.retryDelay,
-        telemetry: { sdk: SDK_TELEMETRY },
+        telemetry: option.disableTelemetry ? void 0 : { sdk: SDK_TELEMETRY },
         flowControl: option.flowControl,
         failureUrl,
         label: option.label
       });
       return {
         workflowContext: context,
-        telemetry: { sdk: SDK_TELEMETRY },
+        telemetry: option.disableTelemetry ? void 0 : { sdk: SDK_TELEMETRY },
         delay: option.delay,
         notBefore: option.notBefore,
         keepTriggerConfig: option.keepTriggerConfig
@@ -4012,6 +4185,7 @@ var Client4 = class {
   WorkflowError,
   WorkflowLogger,
   WorkflowNonRetryableError,
+  WorkflowRetryAfterError,
   WorkflowTool,
   serve
 });