@workflow/world-testing 4.1.7 → 4.1.8

package/dist/.well-known/workflow/v1/flow.js

@@ -48723,7 +48723,7 @@ init_dist();
 init_node();
 
 // ../core/dist/version.js
-var version2 = "4.3.0";
+var version2 = "4.3.1";
 
 // ../core/dist/runtime/world.js
 var import_node_module = require("node:module");
@@ -58332,7 +58332,7 @@ var import_oidc3 = __toESM(require_dist(), 1);
 init_dist();
 
 // ../world-vercel/dist/version.js
-var version3 = "4.3.1";
+var version3 = "4.3.2";
 
 // ../world-vercel/dist/utils.js
 var HTTP_DEBUG_ENABLED = typeof process !== "undefined" && typeof process.env.DEBUG === "string" && (process.env.DEBUG.includes("workflow:") || process.env.DEBUG === "*");
@@ -58343,6 +58343,10 @@ function httpLog(method, endpoint, status, ms2) {
 }
 __name(httpLog, "httpLog");
 var WORKFLOW_SERVER_URL_OVERRIDE = "";
+var REQUEST_TIMEOUT_MS = 6e4;
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
+var MAX_BODY_PARSE_RETRIES = 2;
+var BODY_PARSE_RETRY_BASE_MS = 100;
 var getWorkflowServerUrlOverride = /* @__PURE__ */ __name(() => WORKFLOW_SERVER_URL_OVERRIDE || process.env.VERCEL_WORKFLOW_SERVER_URL || "", "getWorkflowServerUrlOverride");
 var DEFAULT_RESOLVE_DATA_OPTION2 = "all";
 function deserializeError(obj) {
@@ -58471,85 +58475,115 @@ async function makeRequest({ endpoint, options = {}, config: config3 = {}, schem
       ...RpcService3("workflow-server")
     });
     headers.set("Accept", "application/cbor");
-    headers.set("X-Request-Time", Date.now().toString());
     let body;
     if (data !== void 0) {
       headers.set("Content-Type", "application/cbor");
       body = encode3(data);
     }
-    const request = new Request(url2, {
-      ...options,
-      body,
-      headers
-    });
-    const fetchStart = Date.now();
-    const response = await fetch(request, {
-      dispatcher: getDispatcher()
-    });
-    const fetchMs = Date.now() - fetchStart;
-    httpLog(method, endpoint, response.status, fetchMs);
-    span?.setAttributes({
-      ...HttpResponseStatusCode2(response.status)
-    });
-    if (!response.ok) {
-      const errorData = await parseResponseBody(response).then((r) => r.data).catch(() => ({}));
-      if (process.env.DEBUG) {
-        const stringifiedHeaders = Array.from(headers.entries()).filter(([key]) => key.toLowerCase() !== "authorization").map(([key, value]) => `-H "${key}: ${value}"`).join(" ");
-        console.error(`Failed to fetch, reproduce with:
-curl -X ${request.method} ${stringifiedHeaders} "${url2}"`);
-      }
-      let retryAfter;
-      const retryAfterHeader = response.headers.get("Retry-After");
-      if (retryAfterHeader) {
-        const parsed = parseInt(retryAfterHeader, 10);
-        if (!Number.isNaN(parsed)) {
-          retryAfter = parsed;
-        }
-      }
-      const defaultMessage = errorData.message || `${request.method} ${endpoint} -> HTTP ${response.status}: ${response.statusText}`;
-      const throwWithTrace = /* @__PURE__ */ __name((error48) => {
-        span?.setAttributes({
-          ...ErrorType2(errorData.code || `HTTP ${response.status}`)
+    const canRetryBody = IDEMPOTENT_METHODS.has(method.toUpperCase());
+    let parseResult;
+    for (let attempt = 0; ; attempt++) {
+      headers.set("X-Request-Time", Date.now().toString());
+      const timeoutSignal = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+      const signal = options.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
+      const request = new Request(url2, {
+        ...options,
+        body,
+        headers,
+        signal
+      });
+      const fetchStart = Date.now();
+      let response;
+      try {
+        response = await fetch(request, {
+          dispatcher: getDispatcher()
         });
-        span?.recordException?.(error48);
+      } catch (error48) {
+        const elapsed = Date.now() - fetchStart;
+        if (error48 instanceof Error && (error48.name === "TimeoutError" || error48.name === "AbortError")) {
+          const timeoutError = new WorkflowWorldError(`${method} ${endpoint} timed out after ${elapsed}ms`, { url: url2, cause: error48 });
+          span?.setAttributes({ ...ErrorType2("TIMEOUT") });
+          span?.recordException?.(timeoutError);
+          throw timeoutError;
+        }
         throw error48;
-      }, "throwWithTrace");
-      if (response.status === 409) {
-        throwWithTrace(new EntityConflictError(defaultMessage));
       }
-      if (response.status === 410) {
-        throwWithTrace(new RunExpiredError(defaultMessage));
-      }
-      if (response.status === 425) {
-        throwWithTrace(new TooEarlyError(defaultMessage, { retryAfter }));
-      }
-      if (response.status === 429) {
-        throwWithTrace(new ThrottleError(defaultMessage, { retryAfter }));
+      const fetchMs = Date.now() - fetchStart;
+      httpLog(method, endpoint, response.status, fetchMs);
+      span?.setAttributes({
+        ...HttpResponseStatusCode2(response.status)
+      });
+      if (!response.ok) {
+        const errorData = await parseResponseBody(response).then((r) => r.data).catch(() => ({}));
+        if (process.env.DEBUG) {
+          const stringifiedHeaders = Array.from(headers.entries()).filter(([key]) => key.toLowerCase() !== "authorization").map(([key, value]) => `-H "${key}: ${value}"`).join(" ");
+          console.error(`Failed to fetch, reproduce with:
+curl -X ${request.method} ${stringifiedHeaders} "${url2}"`);
+        }
+        let retryAfter;
+        const retryAfterHeader = response.headers.get("Retry-After");
+        if (retryAfterHeader) {
+          const parsed = parseInt(retryAfterHeader, 10);
+          if (!Number.isNaN(parsed)) {
+            retryAfter = parsed;
+          }
+        }
+        const defaultMessage = errorData.message || `${request.method} ${endpoint} -> HTTP ${response.status}: ${response.statusText}`;
+        const throwWithTrace = /* @__PURE__ */ __name((error48) => {
+          span?.setAttributes({
+            ...ErrorType2(errorData.code || `HTTP ${response.status}`)
+          });
+          span?.recordException?.(error48);
+          throw error48;
+        }, "throwWithTrace");
+        if (response.status === 409) {
+          throwWithTrace(new EntityConflictError(defaultMessage));
+        }
+        if (response.status === 410) {
+          throwWithTrace(new RunExpiredError(defaultMessage));
+        }
+        if (response.status === 425) {
+          throwWithTrace(new TooEarlyError(defaultMessage, { retryAfter }));
+        }
+        if (response.status === 429) {
+          throwWithTrace(new ThrottleError(defaultMessage, { retryAfter }));
+        }
+        throwWithTrace(new WorkflowWorldError(defaultMessage, {
+          url: url2,
+          status: response.status,
+          code: errorData.code,
+          retryAfter
+        }));
       }
-      throwWithTrace(new WorkflowWorldError(defaultMessage, {
-        url: url2,
-        status: response.status,
-        code: errorData.code,
-        retryAfter
-      }));
-    }
-    onResponse?.(response);
-    let parseResult;
-    try {
-      parseResult = await trace4("world.parse", async (parseSpan) => {
-        const result2 = await parseResponseBody(response);
-        const contentType = response.headers.get("Content-Type") || "";
-        const isCbor = contentType.includes("application/cbor");
-        parseSpan?.setAttributes({
-          ...WorldParseFormat2(isCbor ? "cbor" : "json")
+      onResponse?.(response);
+      try {
+        parseResult = await trace4("world.parse", async (parseSpan) => {
+          const result2 = await parseResponseBody(response);
+          const contentType = response.headers.get("Content-Type") || "";
+          const isCbor = contentType.includes("application/cbor");
+          parseSpan?.setAttributes({
+            ...WorldParseFormat2(isCbor ? "cbor" : "json")
+          });
+          return result2;
         });
-        return result2;
-      });
-    } catch (error48) {
-      const contentType = response.headers.get("Content-Type") || "unknown";
-      throw new WorkflowWorldError(`Failed to parse response body for ${request.method} ${endpoint} (Content-Type: ${contentType}):
+        break;
+      } catch (error48) {
+        if (canRetryBody && attempt < MAX_BODY_PARSE_RETRIES) {
+          const backoffMs = BODY_PARSE_RETRY_BASE_MS * 2 ** attempt;
+          span?.setAttributes({
+            ...ErrorType2("PARSE_ERROR_RETRYING")
+          });
+          if (HTTP_DEBUG_ENABLED) {
+            console.debug(`[workflow:world-vercel:http] ${method} ${endpoint} body parse failed (attempt ${attempt + 1}/${MAX_BODY_PARSE_RETRIES + 1}); retrying in ${backoffMs}ms: ${error48}`);
+          }
+          await new Promise((resolve3) => setTimeout(resolve3, backoffMs));
+          continue;
+        }
+        const contentType = response.headers.get("Content-Type") || "unknown";
+        throw new WorkflowWorldError(`Failed to parse response body for ${method} ${endpoint} (Content-Type: ${contentType}):
 
 ${error48}`, { url: url2, code: "PARSE_ERROR", cause: error48 });
+      }
     }
     const result = await trace4("world.validate", async () => {
       const validationResult = schema.safeParse(parseResult.data);

package/dist/.well-known/workflow/v1/manifest.json

@@ -6,11 +6,6 @@
                 "stepId": "step//./workflows/null-byte//nullByteStep"
             }
         },
-        "workflows/hooks.ts": {
-            "writeEvent": {
-                "stepId": "step//./workflows/hooks//writeEvent"
-            }
-        },
         "workflows/retriable-and-fatal.ts": {
             "stepThatFails": {
                 "stepId": "step//./workflows/retriable-and-fatal//stepThatFails"
@@ -19,6 +14,21 @@
                 "stepId": "step//./workflows/retriable-and-fatal//stepThatThrowsRetryableError"
             }
         },
+        "workflows/addition.ts": {
+            "add": {
+                "stepId": "step//./workflows/addition//add"
+            }
+        },
+        "workflows/hooks.ts": {
+            "writeEvent": {
+                "stepId": "step//./workflows/hooks//writeEvent"
+            }
+        },
+        "workflows/noop.ts": {
+            "noop": {
+                "stepId": "step//./workflows/noop//noop"
+            }
+        },
         "workflow/dist/internal/builtins.js": {
             "__builtin_response_array_buffer": {
                 "stepId": "__builtin_response_array_buffer"
@@ -29,16 +39,6 @@
             "__builtin_response_text": {
                 "stepId": "__builtin_response_text"
             }
-        },
-        "workflows/addition.ts": {
-            "add": {
-                "stepId": "step//./workflows/addition//add"
-            }
-        },
-        "workflows/noop.ts": {
-            "noop": {
-                "stepId": "step//./workflows/noop//noop"
-            }
         }
     },
     "workflows": {
@@ -75,16 +75,16 @@
                 }
             }
         },
-        "workflows/hooks.ts": {
-            "collectWithHook": {
-                "workflowId": "workflow//./workflows/hooks//collectWithHook",
+        "workflows/retriable-and-fatal.ts": {
+            "retryableAndFatalErrorWorkflow": {
+                "workflowId": "workflow//./workflows/retriable-and-fatal//retryableAndFatalErrorWorkflow",
                 "graph": {
                     "nodes": [
                         {
                             "id": "start",
                             "type": "workflowStart",
                             "data": {
-                                "label": "Start: collectWithHook",
+                                "label": "Start: retryableAndFatalErrorWorkflow",
                                 "nodeKind": "workflow_start"
                             }
                         },
@@ -108,16 +108,16 @@
                 }
             }
         },
-        "workflows/retriable-and-fatal.ts": {
-            "retryableAndFatalErrorWorkflow": {
-                "workflowId": "workflow//./workflows/retriable-and-fatal//retryableAndFatalErrorWorkflow",
+        "workflows/addition.ts": {
+            "addition": {
+                "workflowId": "workflow//./workflows/addition//addition",
                 "graph": {
                     "nodes": [
                         {
                             "id": "start",
                             "type": "workflowStart",
                             "data": {
-                                "label": "Start: retryableAndFatalErrorWorkflow",
+                                "label": "Start: addition",
                                 "nodeKind": "workflow_start"
                             }
                         },
@@ -141,16 +141,16 @@
                 }
             }
         },
-        "workflows/addition.ts": {
-            "addition": {
-                "workflowId": "workflow//./workflows/addition//addition",
+        "workflows/hooks.ts": {
+            "collectWithHook": {
+                "workflowId": "workflow//./workflows/hooks//collectWithHook",
                 "graph": {
                     "nodes": [
                         {
                             "id": "start",
                             "type": "workflowStart",
                             "data": {
-                                "label": "Start: addition",
+                                "label": "Start: collectWithHook",
                                 "nodeKind": "workflow_start"
                             }
                         },