@upstash/workflow 0.2.10 → 0.2.12

package/h3.js

@@ -446,7 +446,7 @@ var formatWorkflowError = (error) => {
     message: error.message
   } : {
     error: "Error",
-    message: "An error occured while executing workflow."
+    message: `An error occured while executing workflow: '${typeof error === "string" ? error : JSON.stringify(error)}'`
   };
 };
 
@@ -463,22 +463,21 @@ function getWorkflowRunId(id) {
   return `wfr_${id ?? nanoid()}`;
 }
 function decodeBase64(base64) {
+  const binString = atob(base64);
   try {
-    const binString = atob(base64);
     const intArray = Uint8Array.from(binString, (m) => m.codePointAt(0));
     return new TextDecoder().decode(intArray);
   } catch (error) {
     console.warn(
       `Upstash Qstash: Failed while decoding base64 "${base64}". Decoding with atob and returning it instead. ${error}`
     );
-    return atob(base64);
+    return binString;
   }
 }
 
 // src/context/steps.ts
-var BaseLazyStep = class {
+var BaseLazyStep = class _BaseLazyStep {
   stepName;
-  // will be set in the subclasses
   constructor(stepName) {
     if (!stepName) {
       throw new WorkflowError(
@@ -487,10 +486,58 @@ var BaseLazyStep = class {
     }
     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;
+    }
+  }
 };
 var LazyFunctionStep = class extends BaseLazyStep {
   stepFunction;
   stepType = "Run";
+  allowUndefinedOut = true;
   constructor(stepName, stepFunction) {
     super(stepName);
     this.stepFunction = stepFunction;
@@ -521,6 +568,7 @@ var LazyFunctionStep = class extends BaseLazyStep {
 var LazySleepStep = class extends BaseLazyStep {
   sleep;
   stepType = "SleepFor";
+  allowUndefinedOut = true;
   constructor(stepName, sleep) {
     super(stepName);
     this.sleep = sleep;
@@ -548,6 +596,7 @@ var LazySleepStep = class extends BaseLazyStep {
 var LazySleepUntilStep = class extends BaseLazyStep {
   sleepUntil;
   stepType = "SleepUntil";
+  allowUndefinedOut = true;
   constructor(stepName, sleepUntil) {
     super(stepName);
     this.sleepUntil = sleepUntil;
@@ -571,8 +620,11 @@ var LazySleepUntilStep = class extends BaseLazyStep {
       concurrent
     });
   }
+  safeParseOut() {
+    return void 0;
+  }
 };
-var LazyCallStep = class extends BaseLazyStep {
+var LazyCallStep = class _LazyCallStep extends BaseLazyStep {
   url;
   method;
   body;
@@ -581,6 +633,7 @@ var LazyCallStep = class extends BaseLazyStep {
   timeout;
   flowControl;
   stepType = "Call";
+  allowUndefinedOut = false;
   constructor(stepName, url, method, body, headers, retries, timeout, flowControl) {
     super(stepName);
     this.url = url;
@@ -612,11 +665,53 @@ var LazyCallStep = class extends BaseLazyStep {
       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 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;
@@ -643,6 +738,13 @@ var LazyWaitForEventStep = class extends BaseLazyStep {
       concurrent
     });
   }
+  safeParseOut(out) {
+    const result = JSON.parse(out);
+    return {
+      ...result,
+      eventData: BaseLazyStep.tryParsing(result.eventData)
+    };
+  }
 };
 var LazyNotifyStep = class extends LazyFunctionStep {
   stepType = "Notify";
@@ -656,10 +758,18 @@ var LazyNotifyStep = class extends LazyFunctionStep {
       };
     });
   }
+  safeParseOut(out) {
+    const result = JSON.parse(out);
+    return {
+      ...result,
+      eventData: BaseLazyStep.tryParsing(result.eventData)
+    };
+  }
 };
 var LazyInvokeStep = class extends BaseLazyStep {
   stepType = "Invoke";
   params;
+  allowUndefinedOut = false;
   constructor(stepName, {
     workflow,
     body,
@@ -699,6 +809,13 @@ var LazyInvokeStep = class extends BaseLazyStep {
       concurrent
     });
   }
+  safeParseOut(out) {
+    const result = JSON.parse(out);
+    return {
+      ...result,
+      body: BaseLazyStep.tryParsing(result.body)
+    };
+  }
 };
 
 // node_modules/neverthrow/dist/index.es.js
@@ -1384,7 +1501,8 @@ var getHeaders = ({
   flowControl,
   callFlowControl
 }) => {
-  const contentType = (userHeaders ? userHeaders.get("Content-Type") : void 0) ?? DEFAULT_CONTENT_TYPE;
+  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,
@@ -1795,7 +1913,7 @@ var AutoExecutor = class _AutoExecutor {
         step,
         stepCount: this.stepCount
       });
-      return step.out;
+      return lazyStep.parseOut(step.out);
     }
     const resultStep = await lazyStep.getResultStep(NO_CONCURRENCY, this.stepCount);
     await this.debug?.log("INFO", "RUN_SINGLE", {
@@ -1870,7 +1988,9 @@ var AutoExecutor = class _AutoExecutor {
       case "last": {
         const parallelResultSteps = sortedSteps.filter((step) => step.stepId >= initialStepCount).slice(0, parallelSteps.length);
         validateParallelSteps(parallelSteps, parallelResultSteps);
-        return parallelResultSteps.map((step) => step.out);
+        return parallelResultSteps.map(
+          (step, index) => parallelSteps[index].parseOut(step.out)
+        );
       }
     }
     const fillValue = void 0;
@@ -1973,7 +2093,7 @@ var AutoExecutor = class _AutoExecutor {
       });
       throw new WorkflowAbort(invokeStep.stepName, invokeStep);
     }
-    const result = await this.context.qstashClient.batchJSON(
+    const result = await this.context.qstashClient.batch(
       steps.map((singleStep, index) => {
         const lazyStep = lazySteps[index];
         const { headers } = getHeaders({
@@ -2003,7 +2123,7 @@ var AutoExecutor = class _AutoExecutor {
           {
             headers,
             method: singleStep.callMethod,
-            body: singleStep.callBody,
+            body: JSON.stringify(singleStep.callBody),
             url: singleStep.callUrl
           }
         ) : (
@@ -2013,7 +2133,7 @@ var AutoExecutor = class _AutoExecutor {
           {
             headers,
             method: "POST",
-            body: singleStep,
+            body: JSON.stringify(singleStep),
             url: this.context.url,
             notBefore: willWait ? singleStep.sleepUntil : void 0,
             delay: willWait ? singleStep.sleepFor : void 0
@@ -2021,8 +2141,9 @@ var AutoExecutor = class _AutoExecutor {
         );
       })
     );
+    const _result = result;
     await this.debug?.log("INFO", "SUBMIT_STEP", {
-      messageIds: result.map((message) => {
+      messageIds: _result.map((message) => {
         return {
           message: message.messageId
         };
@@ -2225,6 +2346,9 @@ 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");
@@ -2244,46 +2368,49 @@ you need from that agent.
 `;
 
 // src/agents/adapters.ts
-var createWorkflowOpenAI = (context, config) => {
-  const { baseURL, apiKey } = config ?? {};
-  return (0, import_openai2.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 fetchWithContextCall = async (context, ...params) => {
+  const [input, init] = params;
+  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 createWorkflowModel = ({
+  context,
+  provider,
+  providerParams
+}) => {
+  return provider({
+    fetch: (...params) => fetchWithContextCall(context, ...params),
+    ...providerParams
   });
 };
 var wrapTools = ({
@@ -2523,9 +2650,14 @@ var WorkflowAgents = class {
   openai(...params) {
     const [model, settings] = params;
     const { baseURL, apiKey, ...otherSettings } = settings ?? {};
-    const openai2 = createWorkflowOpenAI(this.context, { baseURL, apiKey });
-    return openai2(model, otherSettings);
+    const openaiModel = this.AISDKModel({
+      context: this.context,
+      provider: import_openai3.createOpenAI,
+      providerParams: { baseURL, apiKey, compatibility: "strict" }
+    });
+    return openaiModel(model, otherSettings);
   }
+  AISDKModel = createWorkflowModel;
 };
 
 // src/context/context.ts
@@ -2711,7 +2843,7 @@ var WorkflowContext = class {
    */
   async run(stepName, stepFunction) {
     const wrappedStepFunction = () => this.executor.wrapStep(stepName, stepFunction);
-    return this.addStep(new LazyFunctionStep(stepName, wrappedStepFunction));
+    return await this.addStep(new LazyFunctionStep(stepName, wrappedStepFunction));
   }
   /**
    * Stops the execution for the duration provided.
@@ -2782,43 +2914,27 @@ var WorkflowContext = class {
    *   }
    */
   async call(stepName, settings) {
-    const { url, method = "GET", body, headers = {}, retries = 0, timeout, flowControl } = settings;
-    const result = await this.addStep(
+    const {
+      url,
+      method = "GET",
+      body: requestBody,
+      headers = {},
+      retries = 0,
+      timeout,
+      flowControl
+    } = settings;
+    return await this.addStep(
       new LazyCallStep(
         stepName,
         url,
         method,
-        body,
+        requestBody,
         headers,
         retries,
         timeout,
         flowControl
       )
     );
-    if (typeof result === "string") {
-      try {
-        const body2 = JSON.parse(result);
-        return {
-          status: 200,
-          header: {},
-          body: body2
-        };
-      } catch {
-        return {
-          status: 200,
-          header: {},
-          body: result
-        };
-      }
-    }
-    try {
-      return {
-        ...result,
-        body: JSON.parse(result.body)
-      };
-    } catch {
-      return result;
-    }
   }
   /**
    * Pauses workflow execution until a specific event occurs or a timeout is reached.
@@ -2857,15 +2973,7 @@ var WorkflowContext = class {
   async waitForEvent(stepName, eventId, options = {}) {
     const { timeout = "7d" } = options;
     const timeoutStr = typeof timeout === "string" ? timeout : `${timeout}s`;
-    const result = await this.addStep(new LazyWaitForEventStep(stepName, eventId, timeoutStr));
-    try {
-      return {
-        ...result,
-        eventData: JSON.parse(result.eventData)
-      };
-    } catch {
-      return result;
-    }
+    return await this.addStep(new LazyWaitForEventStep(stepName, eventId, timeoutStr));
   }
   /**
    * Notify workflow runs waiting for an event
@@ -2889,24 +2997,12 @@ var WorkflowContext = class {
    * @returns notify response which has event id, event data and list of waiters which were notified
    */
   async notify(stepName, eventId, eventData) {
-    const result = await this.addStep(
+    return await this.addStep(
       new LazyNotifyStep(stepName, eventId, eventData, this.qstashClient.http)
     );
-    try {
-      return {
-        ...result,
-        eventData: JSON.parse(result.eventData)
-      };
-    } catch {
-      return result;
-    }
   }
   async invoke(stepName, settings) {
-    const result = await this.addStep(new LazyInvokeStep(stepName, settings));
-    return {
-      ...result,
-      body: result.body ? JSON.parse(result.body) : void 0
-    };
+    return await this.addStep(new LazyInvokeStep(stepName, settings));
   }
   /**
    * Cancel the current workflow run
@@ -3065,10 +3161,6 @@ var processRawSteps = (rawSteps) => {
   const stepsToDecode = encodedSteps.filter((step) => step.callType === "step");
   const otherSteps = stepsToDecode.map((rawStep) => {
     const step = JSON.parse(decodeBase64(rawStep.body));
-    try {
-      step.out = JSON.parse(step.out);
-    } catch {
-    }
     if (step.waitEventId) {
       const newOut = {
         eventData: step.out ? decodeBase64(step.out) : void 0,
@@ -3288,6 +3380,7 @@ var processOptions = (options) => {
     retries: DEFAULT_RETRIES,
     useJSONContent: false,
     disableTelemetry: false,
+    onError: console.error,
     ...options
   };
 };
@@ -3337,7 +3430,8 @@ var serveBase = (routeFunction, telemetry2, options) => {
     retries,
     useJSONContent,
     disableTelemetry,
-    flowControl
+    flowControl,
+    onError
   } = processOptions(options);
   telemetry2 = disableTelemetry ? void 0 : telemetry2;
   const debug = WorkflowLogger.getLogger(verbose);
@@ -3466,8 +3560,19 @@ var serveBase = (routeFunction, telemetry2, options) => {
     try {
       return await handler(request);
     } catch (error) {
-      console.error(error);
-      return new Response(JSON.stringify(formatWorkflowError(error)), {
+      const formattedError = formatWorkflowError(error);
+      try {
+        onError?.(error);
+      } catch (onErrorError) {
+        const formattedOnErrorError = formatWorkflowError(onErrorError);
+        const errorMessage = `Error while running onError callback: '${formattedOnErrorError.message}'.
+Original error: '${formattedError.message}'`;
+        console.error(errorMessage);
+        return new Response(errorMessage, {
+          status: 500
+        });
+      }
+      return new Response(JSON.stringify(formattedError), {
         status: 500
       });
     }

package/h3.mjs

@@ -2,7 +2,7 @@ import {
   SDK_TELEMETRY,
   serveBase,
   serveManyBase
-} from "./chunk-GFNR743S.mjs";
+} from "./chunk-4GTHIL7S.mjs";
 
 // node_modules/defu/dist/defu.mjs
 function isPlainObject(value) {

package/hono.d.mts

@@ -1,7 +1,7 @@
 import { Context } from 'hono';
-import { R as RouteFunction, k as PublicServeOptions, t as InvokableWorkflow } from './types-CYhDXnf8.mjs';
+import { R as RouteFunction, k as PublicServeOptions, t as InvokableWorkflow } from './types-D1W0VOpy.mjs';
 import { Variables } from 'hono/types';
-import { s as serveManyBase } from './serve-many-BVDpPsF-.mjs';
+import { s as serveManyBase } from './serve-many-DLguU9iR.mjs';
 import '@upstash/qstash';
 import 'zod';
 import 'ai';

package/hono.d.ts

@@ -1,7 +1,7 @@
 import { Context } from 'hono';
-import { R as RouteFunction, k as PublicServeOptions, t as InvokableWorkflow } from './types-CYhDXnf8.js';
+import { R as RouteFunction, k as PublicServeOptions, t as InvokableWorkflow } from './types-D1W0VOpy.js';
 import { Variables } from 'hono/types';
-import { s as serveManyBase } from './serve-many-e4zufyXN.js';
+import { s as serveManyBase } from './serve-many-BdMq5rFX.js';
 import '@upstash/qstash';
 import 'zod';
 import 'ai';